Enum AnyProvider 

pub enum AnyProvider {
    JsonRpcHttp(JsonRpcClient<HttpTransport>),
    SequencerGateway(SequencerGatewayProvider),
}

A convenient Box-able type that implements the Provider trait. This can be useful when you want to accept any built-in provider implementation from the library in your appliation, since the Provider trait itself cannot be Box-ed due to the use of associated type.

A recommended pattern is to make your business logic code (e.g. functions) generic over the Provider trait, while using this AnyProvider type for bootstrapping your application.

NOTE: This type was introduced when Provider was not Box-able. It should be reviewed whether it’s still needed anymore.

Variants

JsonRpcHttp(JsonRpcClient<HttpTransport>)

JSON-RPC provider.

SequencerGateway(SequencerGatewayProvider)

Sequencer gateway provider.

Trait Implementations

impl Debug for AnyProvider

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

Formats the value using the given formatter.

impl Provider for AnyProvider

fn starknet_version<'life0, 'async_trait, B>( &'life0 self, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<String, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns the version of the Starknet being used.

fn spec_version<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the version of the Starknet JSON-RPC specification being used.

fn get_block_with_tx_hashes<'life0, 'async_trait, B>( &'life0 self, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<MaybePreConfirmedBlockWithTxHashes, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets block information with transaction hashes given the block id.

fn get_block_with_txs<'life0, 'async_trait, B>( &'life0 self, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<MaybePreConfirmedBlockWithTxs, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets block information with full transactions given the block id.

fn get_block_with_receipts<'life0, 'async_trait, B>( &'life0 self, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<MaybePreConfirmedBlockWithReceipts, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets block information with full transactions and receipts given the block id.

fn get_state_update<'life0, 'async_trait, B>( &'life0 self, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<MaybePreConfirmedStateUpdate, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the information about the result of executing the requested block.

fn get_storage_at<'life0, 'async_trait, A, K, B>( &'life0 self, contract_address: A, key: K, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<Felt, ProviderError>> + Send + 'async_trait>>

where A: AsRef<Felt> + Send + Sync + 'async_trait, K: AsRef<Felt> + Send + Sync + 'async_trait, B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the value of the storage at the given address and key.

fn get_messages_status<'life0, 'async_trait>( &'life0 self, transaction_hash: Hash256, ) -> Pin<Box<dyn Future<Output = Result<Vec<MessageStatus>, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Given an l1 tx hash, returns the associated l1_handler tx hashes and statuses for all L1 -> L2 messages sent by the l1 transaction, ordered by the l1 tx sending order

fn get_transaction_status<'life0, 'async_trait, H>( &'life0 self, transaction_hash: H, ) -> Pin<Box<dyn Future<Output = Result<TransactionStatus, ProviderError>> + Send + 'async_trait>>

where H: AsRef<Felt> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the transaction status (possibly reflecting that the tx is still in the mempool, or dropped from it).

fn get_transaction_by_hash<'life0, 'async_trait, H>( &'life0 self, transaction_hash: H, ) -> Pin<Box<dyn Future<Output = Result<Transaction, ProviderError>> + Send + 'async_trait>>

where H: AsRef<Felt> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the details and status of a submitted transaction.

fn get_transaction_by_block_id_and_index<'life0, 'async_trait, B>( &'life0 self, block_id: B, index: u64, ) -> Pin<Box<dyn Future<Output = Result<Transaction, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the details of a transaction by a given block id and index.

fn get_transaction_receipt<'life0, 'async_trait, H>( &'life0 self, transaction_hash: H, ) -> Pin<Box<dyn Future<Output = Result<TransactionReceiptWithBlockInfo, ProviderError>> + Send + 'async_trait>>

where H: AsRef<Felt> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the details of a transaction by a given block number and index.

fn get_class<'life0, 'async_trait, B, H>( &'life0 self, block_id: B, class_hash: H, ) -> Pin<Box<dyn Future<Output = Result<ContractClass, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, H: AsRef<Felt> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the contract class definition in the given block associated with the given hash.

fn get_class_hash_at<'life0, 'async_trait, B, A>( &'life0 self, block_id: B, contract_address: A, ) -> Pin<Box<dyn Future<Output = Result<Felt, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, A: AsRef<Felt> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the contract class hash in the given block for the contract deployed at the given address.

fn get_class_at<'life0, 'async_trait, B, A>( &'life0 self, block_id: B, contract_address: A, ) -> Pin<Box<dyn Future<Output = Result<ContractClass, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, A: AsRef<Felt> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the contract class definition in the given block at the given address.

fn get_block_transaction_count<'life0, 'async_trait, B>( &'life0 self, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<u64, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the number of transactions in a block given a block id.

fn call<'life0, 'async_trait, R, B>( &'life0 self, request: R, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<Vec<Felt>, ProviderError>> + Send + 'async_trait>>

where R: AsRef<FunctionCall> + Send + Sync + 'async_trait, B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Calls a starknet function without creating a Starknet transaction.

fn estimate_fee<'life0, 'async_trait, R, S, B>( &'life0 self, request: R, simulation_flags: S, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<Vec<FeeEstimate>, ProviderError>> + Send + 'async_trait>>

where R: AsRef<[BroadcastedTransaction]> + Send + Sync + 'async_trait, S: AsRef<[SimulationFlagForEstimateFee]> + Send + Sync + 'async_trait, B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Estimates the fee for a given Starknet transaction.

fn estimate_message_fee<'life0, 'async_trait, M, B>( &'life0 self, message: M, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<MessageFeeEstimate, ProviderError>> + Send + 'async_trait>>

where M: AsRef<MsgFromL1> + Send + Sync + 'async_trait, B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Estimates the fee for sending an L1-to-L2 message.

fn block_number<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets the most recent accepted block number.

fn block_hash_and_number<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<BlockHashAndNumber, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets the most recent accepted block hash and number.

fn chain_id<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Felt, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the currently configured Starknet chain id.

fn syncing<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<SyncStatusType, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns an object about the sync status, or false if the node is not synching.

fn get_events<'life0, 'async_trait>( &'life0 self, filter: EventFilter, continuation_token: Option<String>, chunk_size: u64, ) -> Pin<Box<dyn Future<Output = Result<EventsPage, ProviderError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all events matching the given filter.

fn get_nonce<'life0, 'async_trait, B, A>( &'life0 self, block_id: B, contract_address: A, ) -> Pin<Box<dyn Future<Output = Result<Felt, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, A: AsRef<Felt> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Gets the nonce associated with the given address in the given block.

fn get_storage_proof<'life0, 'async_trait, B, H, A, K>( &'life0 self, block_id: B, class_hashes: H, contract_addresses: A, contracts_storage_keys: K, ) -> Pin<Box<dyn Future<Output = Result<StorageProof, ProviderError>> + Send + 'async_trait>>

where B: AsRef<ConfirmedBlockId> + Send + Sync + 'async_trait, H: AsRef<[Felt]> + Send + Sync + 'async_trait, A: AsRef<[Felt]> + Send + Sync + 'async_trait, K: AsRef<[ContractStorageKeys]> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Get merkle paths in one of the state tries: global state, classes, individual contract. A single request can query for any mix of the three types of storage proofs (classes, contracts, and storage).

fn add_invoke_transaction<'life0, 'async_trait, I>( &'life0 self, invoke_transaction: I, ) -> Pin<Box<dyn Future<Output = Result<InvokeTransactionResult, ProviderError>> + Send + 'async_trait>>

where I: AsRef<BroadcastedInvokeTransaction> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Submits a new transaction to be added to the chain.

fn add_declare_transaction<'life0, 'async_trait, D>( &'life0 self, declare_transaction: D, ) -> Pin<Box<dyn Future<Output = Result<DeclareTransactionResult, ProviderError>> + Send + 'async_trait>>

where D: AsRef<BroadcastedDeclareTransaction> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Submits a new transaction to be added to the chain.

fn add_deploy_account_transaction<'life0, 'async_trait, D>( &'life0 self, deploy_account_transaction: D, ) -> Pin<Box<dyn Future<Output = Result<DeployAccountTransactionResult, ProviderError>> + Send + 'async_trait>>

where D: AsRef<BroadcastedDeployAccountTransaction> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Submits a new deploy account transaction.

fn trace_transaction<'life0, 'async_trait, H>( &'life0 self, transaction_hash: H, ) -> Pin<Box<dyn Future<Output = Result<TransactionTrace, ProviderError>> + Send + 'async_trait>>

where H: AsRef<Felt> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

For a given executed transaction, returns the trace of its execution, including internal calls.

fn simulate_transactions<'life0, 'async_trait, B, T, S>( &'life0 self, block_id: B, transactions: T, simulation_flags: S, ) -> Pin<Box<dyn Future<Output = Result<Vec<SimulatedTransaction>, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, T: AsRef<[BroadcastedTransaction]> + Send + Sync + 'async_trait, S: AsRef<[SimulationFlag]> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Simulates a given sequence of transactions on the requested state, and generate the execution traces. Note that some of the transactions may revert, in which case no error is thrown, but revert details can be seen on the returned trace object.

fn trace_block_transactions<'life0, 'async_trait, B>( &'life0 self, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionTraceWithHash>, ProviderError>> + Send + 'async_trait>>

where B: AsRef<ConfirmedBlockId> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Retrieves traces for all transactions in the given block.

fn batch_requests<'life0, 'async_trait, R>( &'life0 self, requests: R, ) -> Pin<Box<dyn Future<Output = Result<Vec<ProviderResponseData>, ProviderError>> + Send + 'async_trait>>

where R: AsRef<[ProviderRequestData]> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Sends multiple requests in parallel. The function call fails if any of the requests fails. Implementations must guarantee that responses follow the exact order as the requests.

fn estimate_fee_single<'life0, 'async_trait, R, S, B>( &'life0 self, request: R, simulation_flags: S, block_id: B, ) -> Pin<Box<dyn Future<Output = Result<FeeEstimate, ProviderError>> + Send + 'async_trait>>

where R: AsRef<BroadcastedTransaction> + Send + Sync + 'async_trait, S: AsRef<[SimulationFlagForEstimateFee]> + Send + Sync + 'async_trait, B: AsRef<BlockId> + Send + Sync + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait,

Same as estimate_fee, but only with one estimate.

fn simulate_transaction<'life0, 'async_trait, B, T, S>( &'life0 self, block_id: B, transaction: T, simulation_flags: S, ) -> Pin<Box<dyn Future<Output = Result<SimulatedTransaction, ProviderError>> + Send + 'async_trait>>

where B: AsRef<BlockId> + Send + Sync + 'async_trait, T: AsRef<BroadcastedTransaction> + Send + Sync + 'async_trait, S: AsRef<[SimulationFlag]> + Send + Sync + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait,

Same as simulate_transactions, but only with one simulation.