Struct LightClient 

pub struct LightClient<P, S> {
    db: P,
    server: S,
    opt: LightClientOptions,
    epoch_height: u64,
    first_epoch_with_dynamic_stake_table: EpochNumber,
    genesis_stake_table: Arc<StakeTable>,
    decaf_first_pos_epoch: Option<EpochNumber>,
    stake_tables: RwLock<BTreeMap<EpochNumber, Arc<StakeTable>>>,
}

Client-side state required to implement the light client interface.

A LightClient can always be created from scratch, with no state, since ultimately all data is fetched and verified from external query nodes. However, having some persistent state can make it more efficient to use a LightClient over a long period of time, as important artifacts can be cached locally, avoiding the need to frequently re-fetch and verify them.

Fields

db: P

server: S

opt: LightClientOptions

epoch_height: u64

first_epoch_with_dynamic_stake_table: EpochNumber

genesis_stake_table: Arc<StakeTable>

decaf_first_pos_epoch: Option<EpochNumber>

stake_tables: RwLock<BTreeMap<EpochNumber, Arc<StakeTable>>>

Implementations

impl<P, S> LightClient<P, S>

where P: Storage, S: Client,

pub fn from_genesis(db: P, server: S, genesis: Genesis) -> Self

Create a light client from scratch, with no state.

State will automatically be populated as queries are made. The provided genesis becomes the root of trust for verifying all state that is subsequently loaded by the light client. If the genesis is not correct (i.e. matching the genesis used by honest HotShot nodes) the light client may verify incorrect data, or fail to verify correct data.

pub fn from_genesis_with_options( db: P, server: S, genesis: Genesis, opt: LightClientOptions, ) -> Self

Create a light client from scratch, with no state, using the given options.

State will automatically be populated as queries are made. The provided genesis becomes the root of trust for verifying all state that is subsequently loaded by the light client. If the genesis is not correct (i.e. matching the genesis used by honest HotShot nodes) the light client may verify incorrect data, or fail to verify correct data.

pub async fn block_height(&self) -> Result<u64>

Get the number of known blocks in the chain.

This is equivalent to one more than the block number of the latest known block. The latest known block may come either from the local light client database or from an untrusted query service (in which case the corresponding leaf is fetched and verified to ensure there is in fact such a block). Note however that it is always possible that neither this light client nor the connected server is aware of the true latest block, and so in rare cases the result of this method may be an underestimate.

pub async fn fetch_leaf( &self, id: LeafId<SeqTypes>, ) -> Result<LeafQueryData<SeqTypes>>

Fetch and verify the requested leaf.

async fn fetch_leaf_with_quorum<Q>( &self, id: LeafId<SeqTypes>, quorum: impl Send + FnOnce(EpochNumber) -> Q, ) -> Result<LeafQueryData<SeqTypes>>

where Q: Send + Quorum,

pub async fn fetch_leaves_in_range( &self, start_height: usize, end_height: usize, ) -> Result<Vec<LeafQueryData<SeqTypes>>>

Fetches leaves in range [start_height, end_height)

pub async fn fetch_headers_in_range( &self, start_height: usize, end_height: usize, ) -> Result<Vec<Header>>

Fetches headers in range [start_height, end_height)

async fn fetch_leaves_in_range_from_server( &self, start_height: usize, end_height: usize, known_finalized: &LeafQueryData<SeqTypes>, ) -> Result<Vec<LeafQueryData<SeqTypes>>>

Fetches leaves from the server in range [start_height, end_height) and verifies them by walking backwards from the known finalized leaf, ensuring each leaf’s hash matches the parent commitment of the subsequent leaf.

pub async fn fetch_header(&self, id: BlockId<SeqTypes>) -> Result<Header>

Fetch and verify the requested header.

async fn fetch_header_with_quorum<Q>( &self, id: BlockId<SeqTypes>, quorum: impl Send + FnOnce(EpochNumber) -> Q, ) -> Result<Header>

where Q: Send + Quorum,

pub async fn fetch_payload( &self, id: BlockId<SeqTypes>, ) -> Result<PayloadQueryData<SeqTypes>>

Fetch and verify the requested payload.

pub async fn fetch_payload_for_header( &self, header: Header, ) -> Result<PayloadQueryData<SeqTypes>>

Fetch and verify the full payload with the requested header.

pub async fn fetch_block( &self, id: BlockId<SeqTypes>, ) -> Result<BlockQueryData<SeqTypes>>

Fetch and verify the requested block.

pub async fn fetch_block_for_header( &self, header: Header, ) -> Result<BlockQueryData<SeqTypes>>

Fetch and verify the full block with the requested header.

pub async fn fetch_block_and_vid_common( &self, id: BlockId<SeqTypes>, ) -> Result<(BlockQueryData<SeqTypes>, VidCommonQueryData<SeqTypes>)>

Fetch and verify the requested payload and the associated VID common data.

pub async fn fetch_block_and_vid_common_for_header( &self, header: Header, ) -> Result<(BlockQueryData<SeqTypes>, VidCommonQueryData<SeqTypes>)>

Fetch and verify the payload corresponding to header, and the associated VID common data.

pub async fn fetch_namespace( &self, id: BlockId<SeqTypes>, namespace: NamespaceId, ) -> Result<Vec<Transaction>>

Fetch and verify the transactions in the given namespace of the requested block.

pub async fn fetch_namespace_for_header( &self, header: &Header, namespace: NamespaceId, ) -> Result<Vec<Transaction>>

Fetch and verify the transactions in the given namespace of the requested header.

pub async fn fetch_namespaces_in_range( &self, start_height: usize, end_height: usize, namespace: NamespaceId, ) -> Result<Vec<Vec<Transaction>>>

Fetch and verify the transactions in the given namespace of blocks in the range [start_height, end_height).

pub async fn quorum_for_epoch( &self, epoch: EpochNumber, ) -> Result<Arc<StakeTable>>

Fetch and verify the stake table for the requested epoch.

fn fetch_leaf_from_server<'a, 'b, Q>( &'a self, id: impl Send + Into<LeafRequest> + 'a, known_finalized: Option<&'b Leaf2>, make_quorum: impl 'a + Send + FnOnce(EpochNumber) -> Q, ) -> impl 'b + Send + Future<Output = Result<LeafQueryData<SeqTypes>>>

where Q: Send + Quorum, 'a: 'b,

async fn cache_stake_table( &self, epoch: EpochNumber, stake_table: Arc<StakeTable>, ) -> Arc<StakeTable>

Trait Implementations

impl<P: Debug, S: Debug> Debug for LightClient<P, S>

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

Formats the value using the given formatter.