Struct InMemory 

pub struct InMemory<H>
where
    H: StorageHasher,
{

    pub chain_id: ChainId,
    pub native_token: Address,
    pub block: BlockStorage<H>,
    pub header: Option<BlockHeader>,
    pub last_block: Option<LastBlock>,
    pub last_epoch: Epoch,
    pub next_epoch_min_start_height: BlockHeight,
    pub next_epoch_min_start_time: DateTimeUtc,
    pub address_gen: EstablishedAddressGen,
    pub update_epoch_blocks_delay: Option<u32>,
    pub tx_index: TxIndex,
    pub conversion_state: ConversionState,
    pub expired_txs_queue: ExpiredTxsQueue,
    pub ethereum_height: Option<BlockHeight>,
    pub eth_events_queue: EthEventsQueue,
    pub storage_read_past_height_limit: Option<u64>,
    pub commit_only_data: CommitOnlyData,
    pub block_proposals_cache: CLruCache<Hash, ProcessProposalCachedResult>,
}

The ledger’s state

Fields

chain_id: ChainId

The ID of the chain

native_token: Address

The address of the native token - this is not stored in DB, but read from genesis

block: BlockStorage<H>

Block storage data

header: Option<BlockHeader>

During FinalizeBlock, this is the header of the block that is going to be committed. After a block is committed, this is reset to None until the next FinalizeBlock phase is reached.

last_block: Option<LastBlock>

The most recently committed block, if any.

last_epoch: Epoch

The epoch of the most recently committed block. If it is Epoch(0), then no block may have been committed for this chain yet.

next_epoch_min_start_height: BlockHeight

Minimum block height at which the next epoch may start

next_epoch_min_start_time: DateTimeUtc

Minimum block time at which the next epoch may start

address_gen: EstablishedAddressGen

The current established address generator

update_epoch_blocks_delay: Option<u32>

We delay the switch to a new epoch by the number of blocks set in here. This is Some when minimum number of blocks has been created and minimum time has passed since the beginning of the last epoch. Once the value is Some(0), we’re ready to switch to a new epoch and this is reset back to None.

tx_index: TxIndex

The shielded transaction index

conversion_state: ConversionState

The currently saved conversion state

expired_txs_queue: ExpiredTxsQueue

Queue of expired transactions that need to be retransmitted.

These transactions do not need to be persisted, as they are retransmitted at the COMMIT phase immediately following the block when they were queued.

ethereum_height: Option<BlockHeight>

The latest block height on Ethereum processed, if the bridge is enabled.

eth_events_queue: EthEventsQueue

The queue of Ethereum events to be processed in order.

storage_read_past_height_limit: Option<u64>

How many block heights in the past can the storage be queried

commit_only_data: CommitOnlyData

Data that needs to be committed to the merkle tree

block_proposals_cache: CLruCache<Hash, ProcessProposalCachedResult>

Cache of the results of process proposal for the next height to decide. A LRU cache is used to prevent consuming too much memory at times where a node cannot make progress and keeps evaluating new proposals. The different proposed blocks are indexed by their hash. This is used to avoid running process proposal more than once internally because of the shim or the recheck option (comet only calls it at most once for a given height/round)

Implementations

impl<H> InMemory<H>

where H: StorageHasher,

pub fn new( chain_id: ChainId, native_token: Address, storage_read_past_height_limit: Option<u64>, ) -> Self

Create a new instance of the state

pub fn get_state(&self) -> Option<(MerkleRoot, u64)>

Returns the Merkle root hash and the height of the committed block. If no block exists, returns None.

pub fn merkle_root(&self) -> MerkleRoot

Find the root hash of the merkle tree

pub fn set_header(&mut self, header: BlockHeader) -> Result<()>

Set the block header. The header is not in the Merkle tree as it’s tracked by Tendermint. Hence, we don’t update the tree when this is set.

pub fn begin_block(&mut self, height: BlockHeight) -> Result<()>

Block data is in the Merkle tree as it’s tracked by Tendermint in the block header. Hence, we don’t update the tree when this is set.

pub fn add_tx_gas(&mut self, tx_hash: Hash, gas: Gas)

Store in memory a total gas of a transaction with the given hash.

pub fn get_chain_id(&self) -> (ChainId, Gas)

Get the chain ID as a raw string

pub fn get_block_height(&self) -> (BlockHeight, Gas)

Get the block height. The height is that of the block to which the current transaction is being applied if we are in between the FinalizeBlock and the Commit phases. For all the other phases we return the block height of next block that the consensus process will decide upon (i.e. the block height of the last committed block

pub fn get_current_epoch(&self) -> (Epoch, Gas)

Get the current (yet to be committed) block epoch

pub fn get_last_epoch(&self) -> (Epoch, Gas)

Get the epoch of the last committed block

pub fn init_genesis_epoch( &mut self, initial_height: BlockHeight, genesis_time: DateTimeUtc, parameters: &Parameters, ) -> Result<()>

Initialize the first epoch. The first epoch begins at genesis time.

pub fn get_conversion_state(&self) -> &ConversionState

Get the current conversions

pub fn update_epoch_in_merkle_tree(&mut self) -> Result<()>

Update the merkle tree with epoch data

pub fn get_last_block_height(&self) -> BlockHeight

Get the height of the last committed block or 0 if no block has been committed yet. The first block is at height 1.

pub fn get_oldest_epoch(&self) -> Epoch

Get the oldest epoch where we can read a value

Trait Implementations

impl<H> Debug for InMemory<H>

where H: StorageHasher + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.