block_info.hpp

Go to the documentation of this file.

#pragma once
 
#include <sysio/multi_index.hpp>
#include <sysio/name.hpp>
#include <sysio/time.hpp>
 
#include <limits>
#include <optional>
 
namespace sysiosystem::block_info {
 
static constexpr uint32_t rolling_window_size = 10;
 
struct [[sysio::table, sysio::contract("sysio.system")]] block_info_record
{
   uint8_t           version = 0;
   uint32_t          block_height;
   sysio::time_point block_timestamp;
 
   uint64_t primary_key() const { return block_height; }
 
   SYSLIB_SERIALIZE(block_info_record, (version)(block_height)(block_timestamp))
};
 
using block_info_table = sysio::multi_index<"blockinfo"_n, block_info_record>;
 
struct block_batch_info
{
   uint32_t          batch_start_height;
   sysio::time_point batch_start_timestamp;
   uint32_t          batch_current_end_height;
   sysio::time_point batch_current_end_timestamp;
};
 
struct latest_block_batch_info_result
{
   enum error_code_enum : uint32_t
   {
      no_error,
      invalid_input,
      unsupported_version,
      insufficient_data
   };
 
   std::optional<block_batch_info> result;
   error_code_enum                 error_code = no_error;
};
 
latest_block_batch_info_result get_latest_block_batch_info(uint32_t    batch_start_height_offset,
                                                           uint32_t    batch_size,
                                                           sysio::name system_account_name = "sysio"_n)
{
   latest_block_batch_info_result result;
 
   if (batch_size == 0) {
      result.error_code = latest_block_batch_info_result::invalid_input;
      return result;
   }
 
   block_info_table t(system_account_name, 0);
 
   // Find information on latest block recorded in the blockinfo table.
 
   if (t.cbegin() == t.cend()) {
      // The blockinfo table is empty.
      result.error_code = latest_block_batch_info_result::insufficient_data;
      return result;
   }
 
   auto latest_block_info_itr = --t.cend();
 
   if (latest_block_info_itr->version != 0) {
      // Compiled code for this function within the calling contract has not been updated to support new version of
      // the blockinfo table.
      result.error_code = latest_block_batch_info_result::unsupported_version;
      return result;
   }
 
   uint32_t latest_block_batch_end_height = latest_block_info_itr->block_height;
 
   if (latest_block_batch_end_height < batch_start_height_offset) {
      // Caller asking for a block batch that has not even begun to be recorded yet.
      result.error_code = latest_block_batch_info_result::insufficient_data;
      return result;
   }
 
   // Calculate height for the starting block of the latest block batch.
 
   uint32_t latest_block_batch_start_height =
      latest_block_batch_end_height - ((latest_block_batch_end_height - batch_start_height_offset) % batch_size);
 
   // Note: 1 <= (latest_block_batch_end_height - latest_block_batch_start_height + 1) <= batch_size
 
   if (latest_block_batch_start_height == latest_block_batch_end_height) {
      // When batch_size == 1, this function effectively simplifies to just returning the info of the latest recorded
      // block. In that case, the start block and the end block of the batch are the same and there is no need for
      // another lookup. So shortcut the rest of the process and return a successful result immediately.
      result.result.emplace(block_batch_info{
         .batch_start_height          = latest_block_batch_start_height,
         .batch_start_timestamp       = latest_block_info_itr->block_timestamp,
         .batch_current_end_height    = latest_block_batch_end_height,
         .batch_current_end_timestamp = latest_block_info_itr->block_timestamp,
      });
      return result;
   }
 
   // Find information on start block of the latest block batch recorded in the blockinfo table.
 
   auto start_block_info_itr = t.find(latest_block_batch_start_height);
   if (start_block_info_itr == t.cend() || start_block_info_itr->block_height != latest_block_batch_start_height) {
      // Record for information on start block of the latest block batch could not be found in blockinfo table.
      // This is either because of:
      //    * a gap in recording info due to a failed onblock action;
      //    * a requested start block that was processed by onblock prior to deployment of the system contract code
      //    introducing the blockinfo table;
      //    * or, most likely, because the record for the requested start block was pruned from the blockinfo table as
      //    it fell out of the rolling window.
      result.error_code = latest_block_batch_info_result::insufficient_data;
      return result;
   }
 
   if (start_block_info_itr->version != 0) {
      // Compiled code for this function within the calling contract has not been updated to support new version of
      // the blockinfo table.
      result.error_code = latest_block_batch_info_result::unsupported_version;
      return result;
   }
 
   // Successfully return block_batch_info for the found latest block batch in its current state.
 
   result.result.emplace(block_batch_info{
      .batch_start_height          = latest_block_batch_start_height,
      .batch_start_timestamp       = start_block_info_itr->block_timestamp,
      .batch_current_end_height    = latest_block_batch_end_height,
      .batch_current_end_timestamp = latest_block_info_itr->block_timestamp,
   });
   return result;
}
 
} // namespace sysiosystem::block_info