ab_client_api/

lib.rs

//! Client API

use ab_aligned_buffer::SharedAlignedBuffer;
use ab_core_primitives::address::Address;
use ab_core_primitives::block::owned::{GenericOwnedBlock, OwnedBeaconChainBlock};
use ab_core_primitives::block::{BlockNumber, BlockRoot};
use ab_core_primitives::segments::{
    LocalSegmentIndex, SegmentHeader, SegmentIndex, SegmentRoot, SuperSegmentHeader,
    SuperSegmentIndex,
};
use ab_core_primitives::shard::ShardIndex;
use ab_core_primitives::trees::BlockMerkleMountainRange;
use std::io;
use triomphe::Arc;

/// State of a contract slot
#[derive(Debug, Clone)]
pub struct ContractSlotState {
    /// Owner of the slot
    pub owner: Address,
    /// Contract that manages the slot
    pub contract: Address,
    /// Slot contents
    pub contents: SharedAlignedBuffer,
}

/// Additional details about a block
#[derive(Debug, Clone)]
pub struct BlockDetails {
    /// Merkle Mountain Range with block
    pub mmr_with_block: Arc<BlockMerkleMountainRange>,
    /// System contracts state after block
    pub system_contract_states: Arc<[ContractSlotState]>,
}

// TODO: Probably move it elsewhere
/// Origin
#[derive(Debug, Clone)]
pub enum BlockOrigin {
    // TODO: Take advantage of this in block import
    /// Created locally by block builder
    LocalBlockBuilder {
        /// Additional details about a block
        block_details: BlockDetails,
    },
    /// Received during the sync process
    Sync,
    /// Broadcast on the network during normal operation (not sync)
    Broadcast,
}

/// Intermediate or leaf shard segment root information
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ShardSegmentRoot {
    /// Shard index
    pub shard_index: ShardIndex,
    /// Local segment index
    pub segment_index: LocalSegmentIndex,
    /// Segment root
    pub segment_root: SegmentRoot,
}

/// Error for [`ChainInfo::block()`]
#[derive(Debug, thiserror::Error)]
pub enum ReadBlockError {
    /// Unknown block root
    #[error("Unknown block root")]
    UnknownBlockRoot,
    /// Failed to decode the block
    #[error("Failed to decode the block")]
    FailedToDecode,
    /// Storage item read error
    #[error("Storage item read error")]
    StorageItemReadError {
        /// Low-level error
        #[from]
        error: io::Error,
    },
}

/// Error for [`ChainInfoWrite::persist_block()`]
#[derive(Debug, thiserror::Error)]
pub enum PersistBlockError {
    /// Block is already known
    #[error("Block is already known")]
    AlreadyKnown,
    /// Missing parent
    #[error("Missing parent")]
    MissingParent,
    /// Block is outside the acceptable range
    #[error("Block is outside the acceptable range")]
    OutsideAcceptableRange,
    /// Storage item write error
    #[error("Storage item write error")]
    StorageItemWriteError {
        /// Low-level error
        #[from]
        error: io::Error,
    },
}

/// Error for [`ChainInfoWrite::persist_segment_headers()`]
#[derive(Debug, thiserror::Error)]
pub enum PersistSegmentHeadersError {
    /// Segment index must strictly follow the last segment index, can't store segment header
    #[error(
        "Segment index {local_segment_index} must strictly follow last segment index \
        {last_local_segment_index}, can't store segment header"
    )]
    MustFollowLastSegmentIndex {
        /// Segment index that was attempted to be inserted
        local_segment_index: LocalSegmentIndex,
        /// Last segment index
        last_local_segment_index: LocalSegmentIndex,
    },
    /// The first segment index must be zero
    #[error("First segment index must be zero, found {local_segment_index}")]
    FirstSegmentIndexZero {
        /// Segment index that was attempted to be inserted
        local_segment_index: LocalSegmentIndex,
    },
    /// Storage item write error
    #[error("Storage item write error")]
    StorageItemWriteError {
        /// Low-level error
        #[from]
        error: io::Error,
    },
}

/// Error for [`BeaconChainInfo::shard_segment_roots()`]
#[derive(Debug, thiserror::Error)]
pub enum ShardSegmentRootsError {
    /// Block missing
    #[error("Block {block_number} is missing")]
    BlockMissing {
        /// The block number that is missing in the database
        block_number: BlockNumber,
    },
}

/// Error for [`BeaconChainInfoWrite::persist_super_segment_headers()`]
#[derive(Debug, thiserror::Error)]
pub enum PersistSuperSegmentHeadersError {
    /// Super segment index must strictly follow the last super segment index, can't store super
    /// segment header
    #[error(
        "Super segment index {super_segment_index} must strictly follow last super segment index \
        {last_super_segment_index}, can't store super segment header"
    )]
    MustFollowLastSegmentIndex {
        /// Super segment index that was attempted to be inserted
        super_segment_index: SuperSegmentIndex,
        /// Last super segment index
        last_super_segment_index: SuperSegmentIndex,
    },
    /// The first super segment index must be zero
    #[error("First super segment index must be zero, found {super_segment_index}")]
    FirstSegmentIndexZero {
        /// Super segment index that was attempted to be inserted
        super_segment_index: SuperSegmentIndex,
    },
    /// Storage item write error
    #[error("Storage item write error")]
    StorageItemWriteError {
        /// Low-level error
        #[from]
        error: io::Error,
    },
}

// TODO: Split this into different more narrow traits
/// Chain info.
///
/// NOTE:
/// <div class="warning">
/// Blocks or their parts returned from these APIs are reference-counted and cheap to clone.
/// However, it is not expected that they will be retained in memory for a long time. Blocks and
/// headers will not be pruned until their reference count goes down to one. This is imported when
/// there is an ongoing block import happening and its parent must exist until the import
/// finishes. Forks that can't become a part of the best chain anymore are the exception (see
/// `ConsensusConstants::block_confirmation_depth`), importing their blocks fails instead.
/// </div>
pub trait ChainInfo<Block>: Clone + Send + Sync + 'static
where
    Block: GenericOwnedBlock,
{
    /// Best block root
    fn best_root(&self) -> BlockRoot;

    // TODO: Uncomment if/when necessary
    // /// Find root of ancestor block number for descendant block root
    // fn ancestor_root(
    //     &self,
    //     ancestor_block_number: BlockNumber,
    //     descendant_block_root: &BlockRoot,
    // ) -> Option<BlockRoot>;

    /// Best block header
    fn best_header(&self) -> Block::Header;

    /// Returns the best block header like [`Self::best_header()`] with additional block details
    fn best_header_with_details(&self) -> (Block::Header, BlockDetails);

    /// Get the header of the block at `ancestor_block_number` on the chain ending at
    /// `descendant_block_root`.
    ///
    /// If `ancestor_block_number` is the descendant's own number, the descendant's header is
    /// returned. Returns `None` if `ancestor_block_number` is higher than the descendant's number
    /// or if either block is not available.
    fn ancestor_header(
        &self,
        ancestor_block_number: BlockNumber,
        descendant_block_root: &BlockRoot,
    ) -> Option<Block::Header>;

    /// Block header
    fn header(&self, block_root: &BlockRoot) -> Option<Block::Header>;

    /// Returns a block header like [`Self::header()`] with additional block details
    fn header_with_details(&self, block_root: &BlockRoot) -> Option<(Block::Header, BlockDetails)>;

    fn block(
        &self,
        block_root: &BlockRoot,
    ) -> impl Future<Output = Result<Block, ReadBlockError>> + Send;

    /// Returns the last observed local segment header of this shard
    fn last_segment_header(&self) -> Option<SegmentHeader>;

    /// Get a single segment header
    fn get_segment_header(&self, segment_index: LocalSegmentIndex) -> Option<SegmentHeader>;

    /// Get segment headers that are expected to be included at specified block number
    fn segment_headers_for_block(&self, block_number: BlockNumber) -> Vec<SegmentHeader>;
}

/// [`ChainInfo`] extension for writing information
pub trait ChainInfoWrite<Block>: ChainInfo<Block>
where
    Block: GenericOwnedBlock,
{
    /// Persist newly imported block
    fn persist_block(
        &self,
        block: Block,
        block_details: BlockDetails,
    ) -> impl Future<Output = Result<(), PersistBlockError>> + Send;

    /// Persist segment headers.
    ///
    /// Multiple can be inserted for efficiency purposes.
    fn persist_segment_headers(
        &self,
        segment_headers: Vec<SegmentHeader>,
    ) -> impl Future<Output = Result<(), PersistSegmentHeadersError>> + Send;
}

/// Beacon chain info
pub trait BeaconChainInfo: ChainInfo<OwnedBeaconChainBlock> {
    /// Returns intermediate and leaf shard segment roots included in the specified block number.
    ///
    /// NOTE: Only meant for confirmed blocks (see `ConsensusConstants::block_confirmation_depth`),
    /// which are the same on every chain that can still be extended, so only a block number is
    /// needed as a reference.
    fn shard_segment_roots(
        &self,
        block_number: BlockNumber,
    ) -> Result<Arc<[ShardSegmentRoot]>, ShardSegmentRootsError>;

    /// Returns the last observed super segment header
    fn last_super_segment_header(&self) -> Option<SuperSegmentHeader>;

    /// Returns the previous super segment header for the block built with the specified target
    /// block number.
    ///
    /// `None` is returned for blocks <= 1.
    fn previous_super_segment_header(
        &self,
        block_number: BlockNumber,
    ) -> Option<SuperSegmentHeader>;

    /// Get a single super segment header
    fn get_super_segment_header(
        &self,
        super_segment_index: SuperSegmentIndex,
    ) -> Option<SuperSegmentHeader>;

    /// Get a single super segment header for a segment index
    fn get_super_segment_header_for_segment_index(
        &self,
        segment_index: SegmentIndex,
    ) -> Option<SuperSegmentHeader>;
}

/// [`BeaconChainInfo`] extension for writing information
pub trait BeaconChainInfoWrite: BeaconChainInfo + ChainInfoWrite<OwnedBeaconChainBlock> {
    /// Persist a new super segment header.
    ///
    /// Returns `Ok(true)` if the header was inserted, `Ok(false)` if it was already present.
    fn persist_super_segment_header(
        &self,
        super_segment_header: SuperSegmentHeader,
    ) -> impl Future<Output = Result<bool, PersistSuperSegmentHeadersError>> + Send;

    /// Persist super segment headers.
    ///
    /// Multiple can be inserted for efficiency purposes.
    fn persist_super_segment_headers(
        &self,
        super_segment_headers: Vec<SuperSegmentHeader>,
    ) -> impl Future<Output = Result<(), PersistSuperSegmentHeadersError>> + Send;
}

/// Chain sync status
pub trait ChainSyncStatus: Clone + Send + Sync + 'static {
    /// The block number that the sync process is targeting right now.
    ///
    /// Can be zero if not syncing actively.
    fn target_block_number(&self) -> BlockNumber;

    /// Returns `true` if the chain is currently syncing
    fn is_syncing(&self) -> bool;

    /// Returns `true` if the node is currently offline
    fn is_offline(&self) -> bool;
}