Struct FuelClient

pub struct FuelClient { /* private fields */ }

Implementations

impl FuelClient

pub fn new(url: impl AsRef<str>) -> Result<Self>

pub fn with_required_fuel_block_height( &mut self, new_height: Option<BlockHeight>, ) -> &mut Self

pub fn use_manual_consistency_policy( &mut self, height: Option<BlockHeight>, ) -> &mut Self

pub fn required_block_height(&self) -> Option<BlockHeight>

pub async fn query<ResponseData, Vars>( &self, q: Operation<ResponseData, Vars>, ) -> Result<ResponseData>

where Vars: Serialize, ResponseData: DeserializeOwned + 'static,

Send the GraphQL query to the client.

pub fn latest_stf_version(&self) -> Option<StateTransitionBytecodeVersion>

pub fn latest_consensus_parameters_version( &self, ) -> Option<ConsensusParametersVersion>

pub async fn health(&self) -> Result<bool>

pub async fn node_info(&self) -> Result<NodeInfo>

pub async fn latest_gas_price(&self) -> Result<LatestGasPrice>

pub async fn estimate_gas_price( &self, block_horizon: u32, ) -> Result<EstimateGasPrice>

pub async fn connected_peers_info(&self) -> Result<Vec<PeerInfo>>

pub async fn chain_info(&self) -> Result<ChainInfo>

pub async fn consensus_parameters( &self, version: i32, ) -> Result<Option<ConsensusParameters>>

pub async fn state_transition_byte_code_by_version( &self, version: i32, ) -> Result<Option<StateTransitionBytecode>>

pub async fn state_transition_byte_code_by_root( &self, root: Bytes32, ) -> Result<Option<StateTransitionBytecode>>

pub async fn dry_run( &self, txs: &[Transaction], ) -> Result<Vec<TransactionExecutionStatus>>

Default dry run, matching the exact configuration as the node

pub async fn dry_run_opt( &self, txs: &[Transaction], utxo_validation: Option<bool>, gas_price: Option<u64>, at_height: Option<BlockHeight>, ) -> Result<Vec<TransactionExecutionStatus>>

Dry run with options to override the node behavior

pub async fn storage_read_replay( &self, height: &BlockHeight, ) -> Result<Vec<StorageReadReplayEvent>>

Get storage read replay for a block

pub async fn assemble_tx( &self, tx: &Transaction, block_horizon: u32, required_balances: Vec<RequiredBalance>, fee_address_index: u16, exclude: Option<(Vec<UtxoId>, Vec<Nonce>)>, estimate_predicates: bool, reserve_gas: Option<u64>, ) -> Result<AssembleTransactionResult>

Assembles the transaction based on the provided requirements. The return transaction contains:

• Input coins to cover required_balances
• Input coins to cover the fee of the transaction based on the gas price from block_horizon
• Change or Destroy outputs for all assets from the inputs
• Variable outputs in the case they are required during the execution
• Contract inputs and outputs in the case they are required during the execution
• Reserved witness slots for signed coins filled with 64 zeroes
• Set script gas limit(unless script is empty)
• Estimated predicates, if estimate_predicates == true

Returns an error if:

• The number of required balances exceeds the maximum number of inputs allowed.
• The fee address index is out of bounds.
• The same asset has multiple change policies(either the receiver of the change is different, or one of the policies states about the destruction of the token while the other does not). The Change output from the transaction also count as a ChangePolicy.
• The number of excluded coin IDs exceeds the maximum number of inputs allowed.
• Required assets have multiple entries.
• If accounts don’t have sufficient amounts to cover the transaction requirements in assets.
• If a constructed transaction breaks the rules defined by consensus parameters.

pub async fn estimate_predicates(&self, tx: &mut Transaction) -> Result<()>

Estimate predicates for the transaction

pub async fn submit(&self, tx: &Transaction) -> Result<TransactionId>

pub async fn submit_opt( &self, tx: &Transaction, estimate_predicates: Option<bool>, ) -> Result<TransactionId>

pub async fn submit_and_await_commit( &self, tx: &Transaction, ) -> Result<TransactionStatus>

Similar to Self::submit_and_await_commit_opt, but with default options.

pub async fn submit_and_await_commit_opt( &self, tx: &Transaction, estimate_predicates: Option<bool>, ) -> Result<TransactionStatus>

Submit the transaction and wait for it either to be included in a block or removed from TxPool.

If estimate_predicates is set, the predicates will be estimated before the transaction is inserted into transaction pool.

This will wait forever if needed, so consider wrapping this call with a tokio::time::timeout.

pub async fn submit_and_await_commit_with_tx( &self, tx: &Transaction, ) -> Result<StatusWithTransaction>

Similar to Self::submit_and_await_commit, but the status also contains transaction.

pub async fn submit_and_await_commit_with_tx_opt( &self, tx: &Transaction, estimate_predicates: Option<bool>, ) -> Result<StatusWithTransaction>

Similar to Self::submit_and_await_commit_opt, but the status also contains transaction.

pub async fn submit_and_await_status<'a>( &'a self, tx: &'a Transaction, ) -> Result<impl Stream<Item = Result<TransactionStatus>> + 'a>

Similar to Self::submit_and_await_commit, but includes all intermediate states.

pub async fn submit_and_await_status_opt<'a>( &'a self, tx: &'a Transaction, estimate_predicates: Option<bool>, ) -> Result<impl Stream<Item = Result<TransactionStatus>> + 'a>

Similar to Self::submit_and_await_commit_opt, but includes all intermediate states.

pub async fn contract_storage_slots<'a>( &'a self, contract_id: &'a ContractId, ) -> Result<impl Stream<Item = Result<(Bytes32, Vec<u8>)>> + 'a>

Requests all storage slots for the contract_id.

pub async fn contract_storage_balances<'a>( &'a self, contract_id: &'a ContractId, ) -> Result<impl Stream<Item = Result<ContractBalance>> + 'a>

Requests all storage balances for the contract_id.

pub async fn contract_slots_values( &self, contract_id: &ContractId, block_height: Option<BlockHeight>, requested_storage_slots: Vec<Bytes32>, ) -> Result<Vec<(Bytes32, Vec<u8>)>>

pub async fn contract_balance_values( &self, contract_id: &ContractId, block_height: Option<BlockHeight>, requested_storage_slots: Vec<AssetId>, ) -> Result<Vec<ContractBalance>>

pub async fn start_session(&self) -> Result<String>

pub async fn end_session(&self, id: &str) -> Result<bool>

pub async fn reset(&self, id: &str) -> Result<bool>

pub async fn execute(&self, id: &str, op: &Instruction) -> Result<bool>

pub async fn register(&self, id: &str, register: u32) -> Result<Word>

pub async fn memory(&self, id: &str, start: u32, size: u32) -> Result<Vec<u8>>

pub async fn set_breakpoint( &self, session_id: &str, contract: ContractId, pc: u64, ) -> Result<()>

pub async fn set_single_stepping( &self, session_id: &str, enable: bool, ) -> Result<()>

pub async fn start_tx( &self, session_id: &str, tx: &Transaction, ) -> Result<RunResult>

pub async fn continue_tx(&self, session_id: &str) -> Result<RunResult>

pub async fn transaction( &self, id: &TxId, ) -> Result<Option<TransactionResponse>>

pub async fn transaction_status(&self, id: &TxId) -> Result<TransactionStatus>

Get the status of a transaction

pub async fn subscribe_transaction_status<'a>( &'a self, id: &'a TxId, ) -> Result<impl Stream<Item = Result<TransactionStatus>> + 'a>

Subscribe to the status of a transaction

pub async fn await_transaction_commit( &self, id: &TxId, ) -> Result<TransactionStatus>

Awaits for the transaction to be committed into a block

This will wait forever if needed, so consider wrapping this call with a tokio::time::timeout.

pub async fn transactions( &self, request: PaginationRequest<String>, ) -> Result<PaginatedResult<TransactionResponse, String>>

returns a paginated set of transactions sorted by block height

pub async fn transactions_by_owner( &self, owner: &Address, request: PaginationRequest<String>, ) -> Result<PaginatedResult<TransactionResponse, String>>

Returns a paginated set of transactions associated with a txo owner address.

pub async fn receipts(&self, id: &TxId) -> Result<Option<Vec<Receipt>>>

pub async fn produce_blocks( &self, blocks_to_produce: u32, start_timestamp: Option<u64>, ) -> Result<BlockHeight>

pub async fn block(&self, id: &BlockId) -> Result<Option<Block>>

pub async fn block_by_height( &self, height: BlockHeight, ) -> Result<Option<Block>>

pub async fn da_compressed_block( &self, height: BlockHeight, ) -> Result<Option<Vec<u8>>>

pub async fn blob(&self, id: BlobId) -> Result<Option<Blob>>

Retrieve a blob by its ID

pub async fn blob_exists(&self, id: BlobId) -> Result<bool>

Check whether a blob with ID exists

pub async fn blocks( &self, request: PaginationRequest<String>, ) -> Result<PaginatedResult<Block, String>>

Retrieve multiple blocks

pub async fn coin(&self, id: &UtxoId) -> Result<Option<Coin>>

pub async fn coins( &self, owner: &Address, asset_id: Option<&AssetId>, request: PaginationRequest<String>, ) -> Result<PaginatedResult<Coin, String>>

Retrieve a page of coins by their owner

pub async fn coins_to_spend( &self, owner: &Address, spend_query: Vec<(AssetId, u128, Option<u16>)>, excluded_ids: Option<(Vec<UtxoId>, Vec<Nonce>)>, ) -> Result<Vec<Vec<CoinType>>>

Retrieve coins to spend in a transaction

pub async fn contract(&self, id: &ContractId) -> Result<Option<Contract>>

pub async fn contract_balance( &self, id: &ContractId, asset: Option<&AssetId>, ) -> Result<u64>

pub async fn balance( &self, owner: &Address, asset_id: Option<&AssetId>, ) -> Result<u64>

pub async fn balances( &self, owner: &Address, request: PaginationRequest<String>, ) -> Result<PaginatedResult<Balance, String>>

pub async fn contract_balances( &self, contract: &ContractId, request: PaginationRequest<String>, ) -> Result<PaginatedResult<ContractBalance, String>>

pub async fn message(&self, nonce: &Nonce) -> Result<Option<Message>>

pub async fn messages( &self, owner: Option<&Address>, request: PaginationRequest<String>, ) -> Result<PaginatedResult<Message, String>>

pub async fn contract_info( &self, contract: &ContractId, ) -> Result<Option<Contract>>

pub async fn message_status(&self, nonce: &Nonce) -> Result<MessageStatus>

pub async fn message_proof( &self, transaction_id: &TxId, nonce: &Nonce, commit_block_id: Option<&BlockId>, commit_block_height: Option<BlockHeight>, ) -> Result<MessageProof>

Request a merkle proof of an output message.

pub async fn relayed_transaction_status( &self, id: &Bytes32, ) -> Result<Option<RelayedTransactionStatus>>

pub async fn asset_info(&self, asset_id: &AssetId) -> Result<AssetDetail>

Trait Implementations

impl Clone for FuelClient

fn clone(&self) -> FuelClient

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FuelClient

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

Formats the value using the given formatter.

impl<S> From<S> for FuelClient

where S: Into<SocketAddr>,

fn from(socket: S) -> Self

Converts to this type from the input type.

impl FromStr for FuelClient

type Err = Error

The associated error which can be returned from parsing.

fn from_str(str: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.