Struct Fetcher

pub struct Fetcher {
    pub(crate) peers: Arc<dyn StateCatchup>,
    pub(crate) persistence: Arc<Mutex<dyn MembershipPersistence>>,
    pub(crate) l1_client: L1Client,
    pub(crate) chain_config: Arc<Mutex<ChainConfig>>,
    pub(crate) update_task: Arc<StakeTableUpdateTask>,
}

Fields

peers: Arc<dyn StateCatchup>

Peers for catching up the stake table

persistence: Arc<Mutex<dyn MembershipPersistence>>

Methods for stake table persistence.

l1_client: L1Client

L1 provider

chain_config: Arc<Mutex<ChainConfig>>

Verifiable ChainConfig holding contract address

update_task: Arc<StakeTableUpdateTask>

Implementations

impl Fetcher

pub fn new( peers: Arc<dyn StateCatchup>, persistence: Arc<Mutex<dyn MembershipPersistence>>, l1_client: L1Client, chain_config: ChainConfig, ) -> Self

pub async fn spawn_update_loop(&self)

fn update_loop(&self) -> impl Future<Output = ()>

Periodically updates the stake table from the L1 contract. This function polls the finalized block number from the L1 client at an interval and fetches stake table from contract and updates the persistence

pub async fn fetch_events( &self, contract: Address, to_block: u64, ) -> Result<Vec<(EventKey, StakeTableEvent)>>

pub async fn fetch_events_from_contract( l1_client: L1Client, contract: Address, from_block: Option<u64>, to_block: u64, ) -> StakeTableEvents

Fetch all stake table events from L1

pub async fn fetch_and_store_stake_table_events( &self, contract: Address, to_block: u64, ) -> Result<Vec<(EventKey, StakeTableEvent)>>

Get StakeTable at specific l1 block height. This function fetches and processes various events (ValidatorRegistered, ValidatorExit, Delegated, Undelegated, and ConsensusKeysUpdated) within the block range from the contract’s initialization block to the provided to_block value. Events are fetched in chunks to and retries are implemented for failed requests.

pub async fn fetch_all_validators_from_contract( l1_client: L1Client, contract: Address, to_block: u64, ) -> Result<ValidatorMap>

pub async fn fetch_block_reward(&self) -> Result<RewardAmount, FetchRewardError>

This function is used to calculate the reward for a block. It fetches the initial supply from the token contract.

• We now rely on the Initialized event of the token contract (which should only occur once).
• After locating this event, we fetch its transaction receipt and look for a decoded Transfer log
• If either step fails, the function aborts to prevent incorrect reward calculations.

Relying on mint events directly e.g., searching for mints from the zero address is prone to errors because in future when reward withdrawals are supported, there might be more than one mint transfer logs from zero address

The ESP token contract itself does not expose the initialization block but the stake table contract does The stake table contract is deployed after the token contract as it holds the token contract address. We use the stake table contract initialization block as a safe upper bound when scanning backwards for the token contract initialization event

pub async fn scan_token_contract_initialized_event_log( &self, stake_table_init_block: u64, token: EspTokenInstance<(), L1Provider>, ) -> Result<Log, FetchRewardError>

pub async fn fetch( &self, epoch: <SeqTypes as NodeType>::Epoch, header: Header, ) -> Result<ValidatorMap>

pub(crate) async fn get_chain_config( &self, header: &Header, ) -> Result<ChainConfig>

Retrieve and verify ChainConfig

Trait Implementations

impl Clone for Fetcher

fn clone(&self) -> Fetcher

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Fetcher

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

Formats the value using the given formatter.