Struct RetryableState 

pub struct RetryableState<'a, D> {
    pub timeout_queue: Queue,
    pub arbos_version: u64,
    /* private fields */
}

Manages the collection of retryable tickets.

Fields

timeout_queue: Queue

arbos_version: u64

Implementations

impl<'a, D> RetryableState<'a, D>

pub fn open(sto: Storage<'a, D>, arbos_version: u64) -> Self

pub fn create_retryable<B: StorageBackend>( &self, backend: &mut B, id: B256, timeout: u64, from: Address, to: Option<Address>, callvalue: U256, beneficiary: Address, calldata: &[u8], ) -> Result<Retryable<'a, D>, RetryableError>

Creates a new retryable ticket. The id must be unique.

pub fn open_retryable<B: SystemStateBackend>( &self, backend: &mut B, id: B256, current_timestamp: u64, ) -> Result<Option<Retryable<'a, D>>, RetryableError>

Opens an existing retryable if it is still live.

Past the raw timeout at ArbOS v60+, a kept-alive ticket survives while its windowed timeout has not yet elapsed.

pub fn open_retryable_metered<B: SystemStateBackend>( &self, backend: &mut B, id: B256, current_timestamp: u64, ) -> Result<(Option<Retryable<'a, D>>, u64), RetryableError>

Like [open_retryable], additionally returning the extra storage-read gas the open consumed consulting the lifetime-window slot past the raw timeout. Callers that meter storage access by hand fold this in.

pub fn retryable_size_bytes<B: SystemStateBackend>( &self, backend: &mut B, id: B256, current_time: u64, ) -> Result<u64, RetryableError>

Gets the size in bytes a retryable occupies in storage.

pub fn delete_retryable<F, G, B>( &self, backend: &mut B, id: B256, transfer_fn: F, balance_of: G, ) -> Result<bool, RetryableError>

where F: FnMut(Address, Address, U256) -> Result<(), BalanceError>, G: FnMut(Address) -> U256, B: StorageBackend,

Deletes a retryable and returns whether it existed. Moves the escrow’s entire balance to the beneficiary via the provided closures.

pub fn get_timeout<B: SystemStateBackend>( &self, backend: &mut B, ticket_id: B256, current_timestamp: u64, ) -> Result<RetryableLookup<u64>, RetryableError>

Reads the effective timeout of an open retryable.

Returns NoTicketWithId if the ticket does not exist or has expired.

pub fn get_beneficiary<B: SystemStateBackend>( &self, backend: &mut B, ticket_id: B256, current_timestamp: u64, ) -> Result<RetryableLookup<Address>, RetryableError>

Reads the beneficiary of an open retryable.

Returns NoTicketWithId if the ticket does not exist or has expired.

pub fn calldata_size_for<B: SystemStateBackend>( &self, backend: &mut B, ticket_id: B256, current_timestamp: u64, ) -> Result<(u64, u64), RetryableError>

Returns the calldata size of an open retryable, or zero if it has expired. The lookup never fails the way get_timeout does so the precompile can use it to size its gas reservation regardless of liveness.

pub fn increment_num_tries_for<B: StorageBackend>( &self, backend: &mut B, ticket_id: B256, current_timestamp: u64, ) -> Result<RetryableLookup<u64>, RetryableError>

Increments num_tries on an open retryable and returns the previous value (i.e. the nonce used by the retry transaction).

Returns NoTicketWithId if the ticket is missing or expired.

pub fn keepalive<B: StorageBackend>( &self, backend: &mut B, ticket_id: B256, current_timestamp: u64, limit_before_add: u64, _time_to_add: u64, ) -> Result<RetryableLookup<u64>, RetryableError>

Extends the lifetime of a retryable ticket.

pub fn cancel<B: StorageBackend>( &self, backend: &mut B, ticket_id: B256, caller: Address, current_timestamp: u64, ) -> Result<CancelLookup, RetryableError>

Verifies caller is the beneficiary of an open retryable and clears the ticket’s storage. Returns the calldata size that was cleared so the precompile can derive its gas reservation.

Returns NoTicketWithId for missing/expired tickets and NotBeneficiary when the caller is unauthorised.

pub fn try_to_reap_one_retryable<F, G, B>( &self, backend: &mut B, current_timestamp: u64, transfer_fn: F, balance_of: G, ) -> Result<(), RetryableError>

where F: FnMut(Address, Address, U256) -> Result<(), BalanceError>, G: FnMut(Address) -> U256, B: StorageBackend,

Tries to reap one expired retryable from the timeout queue.

pub fn queue_size<B: SystemStateBackend>( &self, backend: &mut B, ) -> Result<u64, RetryableError>

Total number of pending retryables in the timeout queue.

pub fn snapshot_queue<B: SystemStateBackend>( &self, backend: &mut B, current_time: u64, max_entries: usize, ) -> Result<Vec<(B256, u64)>, RetryableError>

Walk the timeout queue and yield (ticket_id, timeout_seconds) for each non-expired retryable.

impl<D: Database> RetryableState<'_, D>

pub fn initialize(sto: &Storage<'_, D>) -> Result<(), RetryableError>