Struct Client

pub struct Client { /* private fields */ }

A client for gRPC API v2 of the Concordium node. Can be used to control the node, send transactions and query information about the node and the state of the chain.

Connecting to a Concordium node

Creates a new client connection to a Concordium node. Make sure to have access to the gRPC API v2 endpoint of a running node.

use concordium_rust_sdk::v2::{Client, Endpoint};
use std::str::FromStr;

// Assumes the node is running locally and gRPC API v2 can be accessed on port 20001.
let node_endpoint = Endpoint::from_str("http://localhost:20001")?;
let mut client = Client::new(node_endpoint).await?;

// Verify the connection to the node by printing node information.
let node_info = client.get_node_info().await?;
println!("{:#?}", node_info);

Concurrent use of the client

All endpoints take a &mut self as an argument which means that a single instance cannot be used concurrently. However instead of putting the Client behind a Mutex, the intended way to use it is to clone it. Cloning is very cheap and will reuse the underlying connection.

Implementations

impl Client

pub async fn new<E>(endpoint: E) -> Result<Self, Error>

where E: TryInto<Endpoint>, E::Error: Into<Box<dyn Error + Send + Sync + 'static>>,

Construct a new client connection to a concordium node.

Example

Creates a new client. Note the example assumes access to a local running node.

use concordium_rust_sdk::{endpoints::Endpoint, v2::Client};
use std::str::FromStr;

let mut client = Client::new("http://localhost:20001").await?;

pub async fn get_account_info( &mut self, acc: &AccountIdentifier, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<AccountInfo>>

Get the information for the given account in the given block. If either the block or the account do not exist QueryError::NotFound is returned.

pub async fn get_next_account_sequence_number( &mut self, account_address: &AccountAddress, ) -> QueryResult<AccountNonceResponse>

Get the next sequence number for the account, with information on how reliable the information is.

pub async fn get_consensus_info(&mut self) -> QueryResult<ConsensusInfo>

Get information about the current state of consensus. This is an overview of the node’s current view of the chain.

pub async fn get_cryptographic_parameters( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<CryptographicParameters>>

Get the currently used cryptographic parameters. If the block does not exist QueryError::NotFound is returned.

pub async fn get_account_list( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<AccountAddress, Status>>>>

Get the list of accounts in the given block. The stream will end when all accounts that exist in the state at the end of the given block have been returned. If the block does not exist QueryError::NotFound is returned.

pub async fn get_module_list( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<ModuleReference, Status>>>>

Get a list of all smart contract modules. The stream will end when all modules that exist in the state at the end of the given block have been returned. If the block does not exist QueryError::NotFound is returned.

pub async fn get_module_source( &mut self, module_ref: &ModuleReference, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<WasmModule>>

Get the source of a smart contract module. If the block or module does not exist QueryError::NotFound is returned.

pub async fn get_instance_list( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<ContractAddress, Status>>>>

Get the list of smart contract instances in a given block. The stream will end when all instances that exist in the state at the end of the given block have been returned. If the block does not exist QueryError::NotFound is returned.

pub async fn get_instance_info( &mut self, address: ContractAddress, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<InstanceInfo>>

Get information about a smart contract instance as it appears at the end of the given block. If the block or instance does not exist QueryError::NotFound is returned.

pub async fn get_ancestors( &mut self, bi: impl IntoBlockIdentifier, limit: u64, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<BlockHash, Status>>>>

Get a stream of ancestors for the provided block. Starting with the provided block itself, moving backwards until no more ancestors or the requested number of ancestors have been returned.

pub async fn get_finalized_blocks( &mut self, ) -> QueryResult<impl Stream<Item = Result<FinalizedBlockInfo, Status>>>

Return a stream of blocks that are finalized from the time the query is made onward. This can be used to listen for newly finalized blocks.

Note: There is no guarantee that blocks will not be skipped if the client is too slow in processing the stream, however blocks will always be sent by increasing block height.

pub async fn get_instance_state( &mut self, ca: ContractAddress, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<(Vec<u8>, Vec<u8>), Status>>>>

Get the exact state of a specific contract instance, streamed as a list of key-value pairs. The list is streamed in lexicographic order of keys. If the block or instance does not exist QueryError::NotFound is returned.

pub async fn instance_state_lookup( &mut self, ca: ContractAddress, key: impl Into<Vec<u8>>, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<Vec<u8>>>

Get the value at a specific key of a contract state. In contrast to get_instance_state this is more efficient, but requires the user to know the specific key to look for. If the block or instance does not exist QueryError::NotFound is returned.

pub async fn get_block_item_status( &mut self, th: &TransactionHash, ) -> QueryResult<TransactionStatus>

Get the status of and information about a specific block item (transaction). If the block item does not exist QueryError::NotFound is returned.

pub async fn send_block_item<P: PayloadLike>( &mut self, bi: &BlockItem<P>, ) -> RPCResult<TransactionHash>

Send a block item. A block item is either an AccountTransaction, which is a transaction signed and paid for by an account, a CredentialDeployment, which creates a new account, or UpdateInstruction, which is an instruction to change some parameters of the chain. Update instructions can only be sent by the governance committee.

pub async fn send_account_transaction<P: PayloadLike>( &mut self, at: AccountTransaction<P>, ) -> RPCResult<TransactionHash>

Send an account transaction. This is just a helper around send_block_item block item for convenience.

pub async fn get_account_transaction_sign_hash( &mut self, header: &TransactionHeader, payload: &Payload, ) -> RPCResult<TransactionSignHash>

Get the hash to be signed for an account transaction from the node. The hash returned can then be used for signing when constructing TransactionSignature as part of calling Client::send_block_item.

This is provided as a convenience to support cases where the right SDK is not available for interacting with the node.

This SDK can compute the hash off-line and it is not recommended to use this endpoint, instead use compute_transaction_sign_hash.

pub async fn wait_until_finalized( &mut self, hash: &TransactionHash, ) -> QueryResult<(BlockHash, BlockItemSummary)>

Wait until the transaction is finalized. Returns NotFound in case the transaction is not known to the node. In case of success, the return value is a pair of the block hash of the block that contains the transactions, and its outcome in the block.

Since this can take an indefinite amount of time in general, users of this function might wish to wrap it inside timeout handler and handle the resulting failure.

pub async fn invoke_instance( &mut self, bi: impl IntoBlockIdentifier, context: &ContractContext, ) -> QueryResult<QueryResponse<InvokeContractResult>>

Run the smart contract instance entrypoint in a given context and in the state at the end of the given block and return the results. If the block does not exist QueryError::NotFound is returned.

pub async fn begin_dry_run(&mut self) -> QueryResult<DryRun>

Start a dry-run sequence that can be used to simulate a series of transactions and other operations on the node.

Before invoking any other operations on the dry_run::DryRun object, the state must be loaded by calling dry_run::DryRun::load_block_state.

pub async fn dry_run( &mut self, bi: impl IntoBlockIdentifier, ) -> DryRunResult<(DryRun, BlockStateLoaded)>

Start a dry-run sequence that can be used to simulate a series of transactions and other operations on the node, starting from the specified block.

pub async fn get_block_info( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<BlockInfo>>

Get information, such as height, timings, and transaction counts for the given block. If the block does not exist QueryError::NotFound is returned.

pub async fn is_payday_block( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<bool>>

Get information about whether a block identified by bi is a payday block or not. This will always return false for blocks produced prior to protocol version 4. If the block does not exits QueryError::NotFound is returned.

pub async fn get_baker_list( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<BakerId, Status>>>>

Get all the bakers at the end of the given block. If the block does not exist QueryError::NotFound is returned.

pub async fn get_pool_info( &mut self, block_id: impl IntoBlockIdentifier, baker_id: BakerId, ) -> QueryResult<QueryResponse<BakerPoolStatus>>

Get information about a given pool at the end of a given block. If the block does not exist or is prior to protocol version 4 then QueryError::NotFound is returned.

pub async fn get_passive_delegation_info( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<PassiveDelegationStatus>>

Get information about the passive delegators at the end of a given block. If the block does not exist or is prior to protocol version 4 then QueryError::NotFound is returned.

pub async fn get_blocks_at_height( &mut self, blocks_at_height_input: &BlocksAtHeightInput, ) -> QueryResult<Vec<BlockHash>>

Get a list of live blocks at a given height.

pub async fn get_tokenomics_info( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<RewardsOverview>>

Get information about tokenomics at the end of a given block. If the block does not exist QueryError::NotFound is returned.

pub async fn get_pool_delegators( &mut self, bi: impl IntoBlockIdentifier, baker_id: BakerId, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<DelegatorInfo, Status>>>>

Get the registered delegators of a given pool at the end of a given block. If the block or baker ID does not exist QueryError::NotFound is returned, and if the block is baked prior to protocol version 4 QueryError::RPCError with status Code::InvalidArgument is returned. The stream will end when all the delegators have been returned for the given block.

In contrast to the Client::get_pool_delegators_reward_period which returns delegators that are fixed for the reward period of the block, this endpoint returns the list of delegators that are registered in the block. Any changes to delegators are immediately visible in this list.

pub async fn get_pool_delegators_reward_period( &mut self, bi: impl IntoBlockIdentifier, baker_id: BakerId, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<DelegatorRewardPeriodInfo, Status>>>>

Get the fixed delegators of a given pool for the reward period of the given block. If the block or baker ID does not exist QueryError::NotFound is returned, and if the block is baked prior to protocol version 4 QueryError::RPCError with status Code::InvalidArgument is returned. The stream will end when all the delegators have been returned.

In contrast to the Client::get_pool_delegators which returns delegators registered for the given block, this endpoint returns the fixed delegators contributing stake in the reward period containing the given block.

pub async fn get_passive_delegators( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<DelegatorInfo, Status>>>>

Get the registered passive delegators at the end of a given block. If the block does not exist QueryError::NotFound is returned, and if the block is baked prior to protocol version 4 [QueryError:: RPCError] with status Code::InvalidArgument is returned. The stream will end when all the delegators have been returned.

In contrast to the Client::get_passive_delegators_reward_period which returns delegators that are fixed for the reward period of the block, this endpoint returns the list of delegators that are registered in the block. Any changes to delegators are immediately visible in this list.

pub async fn get_passive_delegators_reward_period( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<DelegatorRewardPeriodInfo, Status>>>>

Get the fixed passive delegators for the reward period of the given block. If the block does not exist QueryError::NotFound is returned. If the block is baked prior to protocol version 4, QueryError::RPCError with status Code::InvalidArgument is returned. The stream will end when all the delegators have been returned.

In contrast to the GetPassiveDelegators which returns delegators registered for the given block, this endpoint returns the fixed delegators contributing stake in the reward period containing the given block.

pub async fn get_branches(&mut self) -> QueryResult<Branch>

Get the current branches of blocks starting from and including the last finalized block.

Branches are all live blocks that are successors of the last finalized block. In particular this means that blocks which do not have a parent are not included in this response.

pub async fn get_election_info( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<BirkParameters>>

Get information related to the baker election for a particular block. If the block does not exist QueryError::NotFound is returned.

pub async fn get_identity_providers( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<IpInfo<IpPairing>, Status>>>>

Get the identity providers registered as of the end of a given block. If the block does not exist QueryError::NotFound is returned. The stream will end when all the identity providers have been returned.

pub async fn get_anonymity_revokers( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<ArInfo<ArCurve>, Status>>>>

Get the list of anonymity revokers in the given block. If the block does not exist QueryError::NotFound is returned. The stream will end when all the anonymity revokers have been returned.

pub async fn get_account_non_finalized_transactions( &mut self, account_address: &AccountAddress, ) -> QueryResult<impl Stream<Item = Result<TransactionHash, Status>>>

Get the list of transactions hashes for transactions that claim to be from the given account, but which are not yet finalized. They are either committed to a block or still pending. The stream will end when all the non-finalized transaction hashes have been returned. If the account does not exist an empty list will be returned.

This endpoint is not expected to return a large amount of data in most cases, but in bad network condtions it might.

pub async fn get_block_items( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<BlockItem<EncodedPayload>, Status>>>>

Get the block items included in a given block. If the block does not exist QueryError::NotFound is returned. The stream will end when all the block items in the given block have been returned.

pub async fn get_finalized_block_item( &mut self, th: TransactionHash, ) -> QueryResult<(BlockItem<EncodedPayload>, BlockHash, BlockItemSummary)>

Get the specific block item if it is finalized. If the transaction does not exist in a finalized block QueryError::NotFound is returned.

Note that this is not an efficient method since the node API does not allow for retrieving just the specific block item, but rather requires retrieving the full block. Use it for testing and debugging only.

The return value is a triple of the BlockItem, the hash of the block in which it is finalized, and the outcome in the form of BlockItemSummary.

pub async fn shutdown(&mut self) -> RPCResult<()>

Shut down the node. Return a GRPC error if the shutdown failed.

pub async fn peer_connect(&mut self, addr: SocketAddr) -> RPCResult<()>

Suggest a peer to connect to the submitted peer details. This, if successful, adds the peer to the list of given addresses. Otherwise return a GRPC error.

Note: The peer might not be connected to instantly, in that case the node will try to establish the connection in near future. This function returns a GRPC status ‘Ok’ in this case.

pub async fn peer_disconnect(&mut self, addr: SocketAddr) -> RPCResult<()>

Disconnect from the peer and remove them from the given addresses list if they are on it. Return if the request was processed successfully. Otherwise return a GRPC error.

pub async fn get_banned_peers(&mut self) -> RPCResult<Vec<BannedPeer>>

Get a vector of the banned peers.

pub async fn ban_peer(&mut self, peer_to_ban: PeerToBan) -> RPCResult<()>

Ban a peer. When successful return Ok(()), and otherwise return an error describing the issue.

pub async fn unban_peer(&mut self, banned_peer: &BannedPeer) -> RPCResult<()>

Unban a peer. When successful return Ok(()), and otherwise return an error describing the issue.

pub async fn dump_start(&mut self, file: &Path, raw: bool) -> RPCResult<()>

Start a network dump if the feature is enabled on the node. This writes all the network packets into the given file. Return Ok(()) if a network dump has been initiated, and an error otherwise.

• file - The file to write to.
• raw - Whether raw packets should be included in the dump or not.

Note. If the feature ‘network_dump’ is not enabled on the node then this will return a ‘Precondition failed’ error.

pub async fn dump_stop(&mut self) -> RPCResult<()>

Stop an ongoing network dump. Return nothing if it was successfully stopped, and otherwise return an error.

Note. If the feature ‘network_dump’ is not enabled on the node then this will return a ‘Precondition failed’ error.

pub async fn get_peers_info(&mut self) -> RPCResult<PeersInfo>

Get a list of the peers that the node is connected to and associated network related information for each peer.

pub async fn get_node_info(&mut self) -> RPCResult<NodeInfo>

Retrieve information about the node. The response contains meta information about the node such as the version of the software, the local time of the node etc.

The response also yields network related information such as the node ID, bytes sent/received etc.

Finally depending on the type of the node (regular node or ‘bootstrapper’) the response also yields baking information if the node is configured with baker credentials.

Bootstrappers do no reveal any consensus information as they do not run the consensus protocol.

pub async fn get_baker_earliest_win_time( &mut self, bid: BakerId, ) -> RPCResult<DateTime<Utc>>

Get the projected earliest time a baker wins the opportunity to bake a block. If the baker is not a baker for the current reward period then then the timestamp returned is the projected time of the first block of the new reward period. Note that the endpoint is only available on a node running at least protocol version 6.

pub async fn get_block_transaction_events( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<BlockItemSummary, Status>>>>

Get the transaction events in a given block. If the block does not exist QueryError::NotFound is returned. The stream will end when all the transaction events for a given block have been returned.

pub async fn get_block_special_events( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<SpecialTransactionOutcome, Status>>>>

Get a the special events in a given block. If the block does not exist QueryError::NotFound is returned. The stream will end when all the special events for a given block have been returned.

These are events generated by the protocol, such as minting and reward payouts. They are not directly generated by any transaction.

pub async fn get_block_pending_updates( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<PendingUpdate, Status>>>>

Get the pending updates to chain parameters at the end of a given block. If the block does not exist QueryError::NotFound is returned. The stream will end when all the pending updates for a given block have been returned.

pub async fn get_winning_bakers_epoch( &mut self, ei: impl Into<EpochIdentifier>, ) -> QueryResult<impl Stream<Item = Result<WinningBaker, Status>>>

Get the winning bakers of an historical Epoch. Hence, when this function is invoked using EpochIdentifier::Block and the BlockIdentifier is either BlockIdentifier::Best or BlockIdentifier::LastFinal, then tonic::Code::Unavailable is returned, as these identifiers are not historical by definition.

The stream ends when there are no more rounds for the epoch specified. This only works for epochs in at least protocol version 6. Note that the endpoint is only available on a node running at least protocol version 6.

pub async fn get_first_block_epoch( &mut self, ei: impl Into<EpochIdentifier>, ) -> QueryResult<BlockHash>

Get the first block of the epoch.

pub async fn get_consensus_detailed_status( &mut self, genesis_index: Option<GenesisIndex>, ) -> RPCResult<ConsensusDetailedStatus>

Get the detailed status of the consensus. This is only available for consensus version 1. If the genesis index is not specified, the status for the current genesis index is returned.

pub async fn get_next_update_sequence_numbers( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<NextUpdateSequenceNumbers>>

Get next available sequence numbers for updating chain parameters after a given block. If the block does not exist then QueryError::NotFound is returned.

pub async fn get_scheduled_release_accounts( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<AccountPending, Status>>>>

Get all accounts that have scheduled releases, with the timestamp of the first pending scheduled release for that account. (Note, this only identifies accounts by index, and only indicates the first pending release for each account.)

pub async fn get_cooldown_accounts( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<AccountPending, Status>>>>

Get all accounts that have stake in cooldown, with the timestamp of the first pending cooldown expiry for each account. (Note, this only identifies accounts by index, and only indicates the first pending cooldown for each account.) Prior to protocol version 7, the resulting stream will always be empty.

pub async fn get_pre_cooldown_accounts( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<AccountIndex, Status>>>>

Get all accounts that have stake in pre-cooldown. (This only identifies accounts by index.) Prior to protocol version 7, the resulting stream will always be empty.

pub async fn get_pre_pre_cooldown_accounts( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<AccountIndex, Status>>>>

Get all accounts that have stake in pre-pre-cooldown. (This only identifies accounts by index.) Prior to protocol version 7, the resulting stream will always be empty.

pub async fn get_block_chain_parameters( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<ChainParameters>>

Get the chain parameters in effect after a given block. If the block does not exist QueryError::NotFound is returned.

pub async fn get_block_certificates( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<BlockCertificates>>

For a non-genesis block, this returns the QuorumCertificate, a TimeoutCertificate (if present) and EpochFinalizationEntry (if present). If the block being pointed to is not from protocol version 6 or above, then InvalidArgument is returned.

pub async fn get_block_finalization_summary( &mut self, block_id: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<Option<FinalizationSummary>>>

Get the information about a finalization record in a block. A block can contain zero or one finalization record. If a record is contained then this query will return information about the finalization session that produced it, including the finalizers eligible for the session, their power, and whether they signed this particular record. If the block does not exist QueryError::NotFound is returned.

pub async fn get_finalized_blocks_from( &mut self, start_height: AbsoluteBlockHeight, ) -> QueryResult<FinalizedBlocksStream>

Get a continous stream of finalized blocks starting from a given height. This function starts a background task (a tokio task) that listens for new finalized blocks. This task is killed when the FinalizedBlocksStream is dropped.

pub async fn find_account_creation( &mut self, range: impl RangeBounds<AbsoluteBlockHeight>, addr: AccountAddress, ) -> QueryResult<(AbsoluteBlockHeight, BlockHash, AccountInfo)>

Find a block in which the account was created, if it exists and is finalized. The return value is a triple of the absolute block height and the corresponding block hash, and the account information at the end of that block. The block is the first block in which the account appears.

Note that this is not necessarily the initial state of the account since there can be transactions updating it in the same block that it is created.

Optional bounds can be provided, and the search will only consider blocks in that range. If the lower bound is not provided it defaults to 0, if the upper bound is not provided it defaults to the last finalized block at the time of the call.

If the account cannot be found QueryError::NotFound is returned.

pub async fn find_instance_creation( &mut self, range: impl RangeBounds<AbsoluteBlockHeight>, addr: ContractAddress, ) -> QueryResult<(AbsoluteBlockHeight, BlockHash, InstanceInfo)>

Find a block in which the instance was created, if it exists and is finalized. The return value is a triple of the absolute block height and the corresponding block hash, and the instance information at the end of that block. The block is the first block in which the instance appears.

Note that this is not necessarily the initial state of the instance since there can be transactions updating the instance in the same block as the initialization transaction.

Optional bounds can be provided, and the search will only consider blocks in that range. If the lower bound is not provided it defaults to 0, if the upper bound is not provided it defaults to the last finalized block at the time of the call.

If the instance cannot be found QueryError::NotFound is returned.

pub async fn find_first_finalized_block_no_earlier_than( &mut self, range: impl RangeBounds<AbsoluteBlockHeight>, time: DateTime<Utc>, ) -> QueryResult<BlockInfo>

Find the first (i.e., earliest) finalized block whose slot time is no earlier than the specified time. If a block is not found return QueryError::NotFound.

The search is limited to the bounds specified. If the lower bound is not provided it defaults to 0, if the upper bound is not provided it defaults to the last finalized block at the time of the call.

pub async fn find_at_lowest_height<A, F: Future<Output = QueryResult<Option<A>>>>( &mut self, range: impl RangeBounds<AbsoluteBlockHeight>, test: impl Fn(Self, AbsoluteBlockHeight) -> F, ) -> QueryResult<A>

Find a finalized block with lowest height that satisfies the given condition. If a block is not found return QueryError::NotFound.

The test method should return Some if the object is found in the block, and None otherwise. It can also signal errors which will terminate search immediately.

The precondition for this method is that the test method is monotone, i.e., if block at height h satisfies the test then also a block at height h+1 does. If this precondition does not hold then the return value from this method is unspecified.

The search is limited to at most the given range, the upper bound is always at most the last finalized block at the time of the call. If the lower bound is not provided it defaults to 0, if the upper bound is not provided it defaults to the last finalized block at the time of the call.

pub async fn find_earliest_finalized<A, F: Future<Output = QueryResult<Option<A>>>>( &mut self, range: impl RangeBounds<AbsoluteBlockHeight>, test: impl Fn(Self, AbsoluteBlockHeight, BlockHash) -> F, ) -> QueryResult<A>

👎Deprecated: Use find_at_lowest_height instead since it avoids an extra call.

pub async fn get_bakers_reward_period( &mut self, bi: impl IntoBlockIdentifier, ) -> QueryResult<QueryResponse<impl Stream<Item = Result<BakerRewardPeriodInfo, Status>>>>

Get all bakers in the reward period of a block. This endpoint is only supported for protocol version 4 and onwards. If the protocol does not support the endpoint then an IllegalArgument is returned.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Client

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

Formats the value using the given formatter.