Trait sc_client_api::backend::Backend[−][src]

pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
    type BlockImportOperation: BlockImportOperation<Block, State = Self::State>;
    type Blockchain: BlockchainBackend<Block>;
    type State: StateBackend<HashFor<Block>> + Send;
    type OffchainStorage: OffchainStorage;

Show methods    fn begin_operation(&self) -> Result<Self::BlockImportOperation>;

    fn begin_state_operation(
        &self, 
        operation: &mut Self::BlockImportOperation, 
        block: BlockId<Block>
    ) -> Result<()>;

    fn commit_operation(
        &self, 
        transaction: Self::BlockImportOperation
    ) -> Result<()>;

    fn finalize_block(
        &self, 
        block: BlockId<Block>, 
        justification: Option<Justification>
    ) -> Result<()>;

    fn append_justification(
        &self, 
        block: BlockId<Block>, 
        justification: Justification
    ) -> Result<()>;

    fn blockchain(&self) -> &Self::Blockchain;

    fn usage_info(&self) -> Option<UsageInfo>;

    fn changes_trie_storage(
        &self
    ) -> Option<&dyn PrunableStateChangesTrieStorage<Block>>;

    fn offchain_storage(&self) -> Option<Self::OffchainStorage>;

    fn state_at(&self, block: BlockId<Block>) -> Result<Self::State>;

    fn revert(
        &self, 
        n: NumberFor<Block>, 
        revert_finalized: bool
    ) -> Result<(NumberFor<Block>, HashSet<Block::Hash>)>;

    fn remove_leaf_block(&self, hash: &Block::Hash) -> Result<()>;

    fn get_import_lock(&self) -> &RwLock<()>;

    fn have_state_at(
        &self, 
        hash: &Block::Hash, 
        _number: NumberFor<Block>
    ) -> bool { ... }

    fn insert_aux<'a, 'b: 'a, 'c: 'a, I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>, D: IntoIterator<Item = &'a &'b [u8]>>(
        &self, 
        insert: I, 
        delete: D
    ) -> Result<()> { ... }

    fn get_aux(&self, key: &[u8]) -> Result<Option<Vec<u8>>> { ... }

}
Expand description

Client backend.

Manages the data layer.

Note on state pruning: while an object from state_at is alive, the state should not be pruned. The backend should internally reference-count its state objects.

The same applies for live BlockImportOperations: while an import operation building on a parent P is alive, the state for P should not be pruned.

Associated Types

Associated block insertion operation type.

Associated blockchain backend type.

Associated state backend type.

Offchain workers local storage.

Required methods

Begin a new block insertion transaction with given parent block id.

When constructing the genesis, this is called with all-zero hash.

Note an operation to contain state transition.

Commit block insertion.

Finalize block with given Id.

This should only be called if the parent of the given block has been finalized.

Append justification to the block with the given Id.

This should only be called for blocks that are already finalized.

Returns reference to blockchain backend.

Returns current usage statistics.

Returns reference to changes trie storage.

Returns a handle to offchain storage.

Returns state backend with post-state of given block.

Attempts to revert the chain by n blocks. If revert_finalized is set it will attempt to revert past any finalized block, this is unsafe and can potentially leave the node in an inconsistent state.

Returns the number of blocks that were successfully reverted and the list of finalized blocks that has been reverted.

Discard non-best, unfinalized leaf block.

Gain access to the import lock around this backend.

Note Backend isn’t expected to acquire the lock by itself ever. Rather the using components should acquire and hold the lock whenever they do something that the import of a block would interfere with, e.g. importing a new block or calculating the best head.

Provided methods

Returns true if state for given block is available.

Insert auxiliary data into key-value store.

Query auxiliary data from key-value store.

Implementors