Struct Shell 

pub struct Shell<D = PersistentDB, H = Sha256Hasher>
where
    D: DB + for<'iter> DBIter<'iter> + Sync + 'static,
    H: StorageHasher + Sync + 'static,
{
    pub chain_id: ChainId,
    pub state: FullAccessState<D, H>,
    pub vp_wasm_cache: VpCache<WasmCacheRwAccess>,
    pub tx_wasm_cache: TxCache<WasmCacheRwAccess>,
    pub scheduled_migration: Option<ScheduledMigration>,
    pub blocks_between_snapshots: Option<NonZeroU64>,
    pub syncing: Option<SnapshotSync>,
    /* private fields */
}

Fields

chain_id: ChainId

The id of the current chain

state: FullAccessState<D, H>

The persistent storage with write log

vp_wasm_cache: VpCache<WasmCacheRwAccess>

VP WASM compilation cache

tx_wasm_cache: TxCache<WasmCacheRwAccess>

Tx WASM compilation cache

scheduled_migration: Option<ScheduledMigration>

A migration that can be scheduled at a given block height

blocks_between_snapshots: Option<NonZeroU64>

When set, indicates after how many blocks a new snapshot will be taken (counting from the first block)

syncing: Option<SnapshotSync>

Data for a node downloading and apply snapshots as part of the fast sync protocol.

Implementations

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn finalize_block( &mut self, req: FinalizeBlock, ) -> ShellResult<FinalizeBlock>

Updates the chain with new header, height, etc. Also keeps track of epoch changes and applies associated updates to validator sets, etc. as necessary.

Apply the transactions included in the block.

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn init_chain(&mut self, init: InitChain) -> ShellResult<InitChain>

Create a new genesis for the chain with specified id. This includes

1. A set of initial users and tokens
2. Setting up the validity predicates for both users and tokens
3. Validators
4. The PoS system
5. The Ethereum bridge parameters

INVARIANT: This method must not commit the state changes to DB.

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn prepare_proposal(&self, req: RequestPrepareProposal) -> PrepareProposal

Begin a new block.

Block construction is documented in block_alloc and block_alloc::states (private modules).

INVARIANT: Any changes applied in this method must be reverted if the proposal is rejected (unless we can simply overwrite them in the next block). Furthermore, protocol transactions cannot affect the ability of a tx to pay its wrapper fees.

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn verify_header(&self, _req: VerifyHeader) -> VerifyHeader

INVARIANT: This method must be stateless.

pub fn process_proposal( &self, req: RequestProcessProposal, ) -> (ProcessProposal, Vec<TxResult>)

Check all the txs in a block. Some txs may be incorrect, but we only reject the entire block if the order of the included txs violates the order decided upon in the previous block.

pub fn process_txs( &self, txs: &[TxBytes], block_time: DateTimeUtc, block_proposer: &Address, ) -> Vec<TxResult>

Evaluates the corresponding TxResult for each tx in the proposal.

ProcessProposal should be able to make a decision on whether a proposed block is acceptable or not based solely on what this function returns.

pub fn check_proposal_tx<CA>( &self, tx_bytes: &[u8], tx_index: &TxIndex, metadata: &mut ValidationMeta, temp_state: &mut TempWlState<'static, D, H>, block_time: DateTimeUtc, vp_wasm_cache: &mut VpCache<CA>, tx_wasm_cache: &mut TxCache<CA>, block_proposer: &Address, ) -> TxResult

where CA: 'static + WasmCacheAccess + Sync,

Checks if the Tx can be deserialized from bytes. Checks the fees and signatures of the fee payer for a transaction if it is a wrapper tx.

Checks validity of an inner tx.

Error codes: 0: Ok 1: Wasm runtime error 2: Invalid tx 3: Tx is invalidly signed 4: Block is full 5: Replay attempt 6. Tx targets a different chain id 7. Tx is expired 8. Tx exceeds the gas limit 9. Tx failed to pay fees 10. An error in the vote extensions included in the proposal 11. Not enough block space was available for some tx 12. Tx wasm code is not allowlisted

INVARIANT: This function should not, under any circumstances, modify the state since the proposal could be rejected.

pub fn revert_proposal(&mut self, _req: RevertProposal) -> RevertProposal

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn query(&self, query: Query) -> Query

Uses path in the query to forward the request to the right query method and returns the result (which may be the default if path is not a supported string. INVARIANT: This method must be stateless.

pub fn get_balance(&self, token: &Address, owner: &Address) -> Amount

Simple helper function for the ledger to get balances of the specified token at the specified address

impl Shell<PersistentDB, Sha256Hasher>

pub fn list_snapshots(&self) -> ListSnapshots

List the snapshot files held locally. Furthermore, the number of chunks, as hash of each chunk, and a hash of the chunk metadata are provided so that syncing nodes can verify snapshots they receive.

pub fn load_snapshot_chunk(&self, req: LoadSnapshotChunk) -> LoadSnapshotChunk

Load the bytes of a requested chunk and return them to cometbft.

pub fn offer_snapshot(&mut self, req: OfferSnapshot) -> OfferSnapshot

Decide if a snapshot should be accepted to sync the node forward in time

pub fn apply_snapshot_chunk( &mut self, req: ApplySnapshotChunk, ) -> ApplySnapshotChunk

Write a snapshot chunk to the database

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn validate_bp_roots_vext_list<'iter>( &'iter self, vote_extensions: impl IntoIterator<Item = Signed<Vext>> + 'iter, ) -> impl Iterator<Item = Result<Signed<Vext>, VoteExtensionError>> + 'iter

Takes an iterator over Bridge pool root vote extension instances, and returns another iterator. The latter yields valid Bridge pool root vote extensions, or the reason why these are invalid, in the form of a VoteExtensionError.

pub fn filter_invalid_bp_roots_vexts<'iter>( &'iter self, vote_extensions: impl IntoIterator<Item = Signed<Vext>> + 'iter, ) -> impl Iterator<Item = Signed<Vext>> + 'iter

Takes a list of signed Bridge pool root vote extensions, and filters out invalid instances. This also de-duplicates the iterator to be unique per validator address.

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn new_ethereum_events(&mut self) -> Vec<EthereumEvent>

Checks the channel from the Ethereum oracle monitoring the fullnode and retrieves all seen Ethereum events.

pub fn validate_eth_events_vext_list<'iter>( &'iter self, vote_extensions: impl IntoIterator<Item = Signed<Vext>> + 'iter, ) -> impl Iterator<Item = Result<Signed<Vext>, VoteExtensionError>> + 'iter

Takes an iterator over Ethereum events vote extension instances, and returns another iterator. The latter yields valid Ethereum events vote extensions, or the reason why these are invalid, in the form of a VoteExtensionError.

pub fn filter_invalid_eth_events_vexts<'iter>( &'iter self, vote_extensions: impl IntoIterator<Item = Signed<Vext>> + 'iter, ) -> impl Iterator<Item = Signed<Vext>> + 'iter

Takes a list of signed Ethereum events vote extensions, and filters out invalid instances.

pub fn compress_ethereum_events( &self, vote_extensions: Vec<Signed<Vext>>, ) -> Option<VextDigest>

Compresses a set of signed Ethereum events into a single ethereum_events::VextDigest, whilst filtering invalid Signed<ethereum_events::Vext> instances in the process.

When vote extensions are being used, this performs a check that at least 2/3 of the validators by voting power have included ethereum events in their vote extension.

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn validate_valset_upd_vext_list( &self, vote_extensions: impl IntoIterator<Item = SignedVext> + 'static, ) -> impl Iterator<Item = Result<SignedVext, VoteExtensionError>> + '_

Takes an iterator over validator set update vote extension instances, and returns another iterator. The latter yields valid validator set update vote extensions, or the reason why these are invalid, in the form of a VoteExtensionError.

pub fn filter_invalid_valset_upd_vexts( &self, vote_extensions: impl IntoIterator<Item = SignedVext> + 'static, ) -> impl Iterator<Item = SignedVext> + '_

Takes a list of signed validator set update vote extensions, and filters out invalid instances.

pub fn compress_valset_updates( &self, vote_extensions: Vec<SignedVext>, ) -> Option<VextDigest>

Compresses a set of signed validator set update vote extensions into a single validator_set_update::VextDigest, whilst filtering invalid validator_set_update::SignedVext instances in the process.

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn craft_extension(&mut self) -> VoteExtension

Creates the data to be added to a vote extension.

INVARIANT: This method must be stateless.

pub fn extend_vote_with_ethereum_events(&mut self) -> Option<Signed<Vext>>

Extend PreCommit votes with ethereum_events::Vext instances.

pub fn sign_ethereum_events( &self, ethereum_events: Vec<EthereumEvent>, ) -> Option<Signed<Vext>>

Sign the given Ethereum events, and return the associated vote extension protocol transaction.

pub fn extend_vote_with_bp_roots(&self) -> Option<Signed<Vext>>

Extend PreCommit votes with bridge_pool_roots::Vext instances.

pub fn extend_vote_with_valset_update(&self) -> Option<SignedVext>

Extend PreCommit votes with validator_set_update::Vext instances.

pub fn deserialize_vote_extensions<'shell>( &'shell self, txs: &'shell mut Vec<TxBytes>, ) -> DrainFilter<'shell, TxBytes, impl FnMut(&mut TxBytes) -> bool + 'shell>

Given a slice of TxBytes, return an iterator over the ones we could deserialize to vote extension protocol txs.

impl Shell<PersistentDB, Sha256Hasher>

pub fn restore_database_from_state_sync(&mut self)

Restore the database with data fetched from the State Sync protocol.

impl<D, H> Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static, H: StorageHasher + Sync + 'static,

pub fn new( config: Ledger, wasm_dir: PathBuf, broadcast_sender: UnboundedSender<Vec<u8>>, eth_oracle: Option<EthereumOracleChannels>, db_cache: Option<&D::Cache>, scheduled_migration: Option<ScheduledMigration>, vp_wasm_compilation_cache: u64, tx_wasm_compilation_cache: u64, ) -> Self

Create a new shell from a path to a database and a chain id. Looks up the database with this data and tries to load the last state.

pub fn event_log(&self) -> &EventLog

Return a reference to the EventLog.

pub fn event_log_mut(&mut self) -> &mut EventLog

Return a mutable reference to the EventLog.

pub fn last_state(&self, namada_version: &str) -> Info

Load the Merkle root hash and the height of the last committed block, if any. This is returned when ABCI sends an info request.

pub fn read_storage_key<T>(&self, key: &Key) -> Option<T>

where T: Clone + BorshDeserialize,

Read the value for a storage key dropping any error

pub fn read_storage_key_bytes(&self, key: &Key) -> Option<Vec<u8>>

Read the bytes for a storage key dropping any error

pub fn get_validator_set_update_epoch(&self, current_epoch: Epoch) -> Epoch

Get the next epoch for which we can request validator set changed

pub fn commit(&mut self) -> Response

Commit a block. Persist the application state and return the Merkle root hash.

pub fn mempool_validate(&self, tx_bytes: &[u8], _type: MempoolTxType) -> CheckTx

Validate a transaction request. On success, the transaction will included in the mempool and propagated to peers, otherwise it will be rejected.

pub fn get_current_decision_height(&self) -> BlockHeight

Retrieves the BlockHeight that is currently being decided.

pub fn is_deciding_offset_within_epoch(&self, height_offset: u64) -> bool

Check if we are at a given BlockHeight offset, height_offset, within the current epoch.

Trait Implementations

impl<D, H> Debug for Shell<D, H>

where D: DB + for<'iter> DBIter<'iter> + Sync + 'static + Debug, H: StorageHasher + Sync + 'static + Debug,

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

Formats the value using the given formatter.