Struct FuelClient

pub struct FuelClient { /* private fields */ }

Implementations

impl FuelClient

pub fn new(url: impl AsRef<str>) -> Result<FuelClient, Error>

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

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

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

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

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

Send the GraphQL query to the client.

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

pub fn latest_consensus_parameters_version(&self) -> Option<u32>

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

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

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

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

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

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

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

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

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

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>, Error>

Dry run with options to override the node behavior

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

Like dry_run_opt, but also returns the storage reads

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

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, Error>

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<(), Error>

Estimate predicates for the transaction

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Get the status of a transaction

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

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>, Error>

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

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

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

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

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

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

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

Retrieve a blob by its ID

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

Check whether a blob with ID exists

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

Retrieve multiple blocks

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

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

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>>, Error>

Retrieve coins to spend in a transaction

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

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

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

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

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

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

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

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

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

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

Request a merkle proof of an output message.

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

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

Trait Implementations

impl Clone for FuelClient

fn clone(&self) -> FuelClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FuelClient

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

Formats the value using the given formatter.

impl<S> From<S> for FuelClient

where S: Into<SocketAddr>,

fn from(socket: S) -> FuelClient

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<FuelClient, <FuelClient as FromStr>::Err>

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