Struct ContractClient 

pub struct ContractClient<Type> {
    pub client: Client,
    pub address: ContractAddress,
    pub contract_name: Arc<OwnedContractName>,
    pub schema: Arc<Option<VersionedModuleSchema>>,
    /* private fields */
}

A contract client that handles some of the boilerplate such as serialization and parsing of responses when sending transactions, or invoking smart contracts.

Note that cloning is cheap and is, therefore, the intended way of sharing values of this type between multiple tasks.

Fields

client: Client

The underlying network client.

address: ContractAddress

The address of the instance.

contract_name: Arc<OwnedContractName>

The name of the contract at the address.

schema: Arc<Option<VersionedModuleSchema>>

The schema of the contract at the address.

Implementations

impl<Type> ContractClient<Type>

pub async fn create( client: Client, address: ContractAddress, ) -> QueryResult<Self>

Construct a ContractClient by looking up metadata from the chain (such as the contract_name and the embedded schema).

Arguments

• client - The RPC client for the concordium node.
• address - The contract address of the smart contract instance.

pub fn new( client: Client, address: ContractAddress, contract_name: OwnedContractName, ) -> Self

Construct a ContractClient locally. In comparison to create this always succeeds and does not check existence of the contract.

Arguments

• client - The RPC client for the concordium node. Note that cloning Client is cheap and is therefore the intended way of sharing.
• address - The contract address of the smart contract.
• contract_name - The name of the contract. This must match the name on the chain, otherwise the constructed client will not work.

pub fn new_with_schema( client: Client, address: ContractAddress, contract_name: OwnedContractName, schema: VersionedModuleSchema, ) -> Self

Construct a ContractClient locally. In comparison to create this always succeeds and does not check existence of the contract and does not look up metadata from the chain (such as embedded schemas). In comparison to new this constructor also takes a versioned module schema.

Arguments

• client - The RPC client for the concordium node. Note that cloning Client is cheap and is therefore the intended way of sharing.
• address - The contract address of the smart contract.
• contract_name - The name of the contract. This must match the name on the chain, otherwise the constructed client will not work.
• schema - A versioned module schema of the contract. It is used by the client to decode the error codes in rejected transactions.

pub async fn view<P: Serial, A: Deserial, E>( &mut self, entrypoint: &str, parameter: &P, bi: impl IntoBlockIdentifier, ) -> Result<A, E>

where E: From<NewReceiveNameError> + From<RejectReason> + From<ParseError> + From<QueryError> + From<ExceedsParameterSize>,

Invoke a contract and return the response.

This will always fail for a V0 contract, and for V1 contracts it will attempt to deserialize the response into the provided type A.

The error E is left generic in order to support specialized errors such as CIS2 or CIS4 specific errors for more specialized view functions defined by those standards.

For a general contract ViewError can be used as a concrete error type E.

pub async fn view_raw<A: Deserial, E>( &mut self, entrypoint: &str, parameter: OwnedParameter, bi: impl IntoBlockIdentifier, ) -> Result<A, E>

where E: From<NewReceiveNameError> + From<RejectReason> + From<ParseError> + From<QueryError>,

Like view but expects an already serialized parameter.

pub async fn invoke_raw<E>( &mut self, entrypoint: &str, amount: Amount, invoker: Option<Address>, parameter: OwnedParameter, bi: impl IntoBlockIdentifier, ) -> Result<InvokeContractResult, E>

where E: From<NewReceiveNameError> + From<RejectReason> + From<QueryError>,

Invoke a contract instance and return the response without any processing.

pub async fn dry_run_update<P: Serial, E>( &mut self, entrypoint: &str, amount: Amount, sender: AccountAddress, message: &P, ) -> Result<ContractUpdateBuilder, E>

where E: From<NewReceiveNameError> + From<RejectReason> + From<QueryError> + From<ExceedsParameterSize>,

Dry run an update. If the dry run succeeds the return value is an object that has a send method to send the transaction that was simulated during the dry run.

The arguments are

• entrypoint the name of the entrypoint to be invoked. Note that this is just the entrypoint name without the contract name.
• amount the amount of CCD to send to the contract instance
• sender the account that will be sending the transaction
• message the parameter to the smart contract entrypoint.

pub async fn dry_run_update_with_reject_reason_info<P: Serial, E>( &mut self, entrypoint: &str, amount: Amount, sender: AccountAddress, message: &P, ) -> Result<InvokeContractOutcome, E>

where E: From<NewReceiveNameError> + From<QueryError> + From<ExceedsParameterSize>,

Dry run an update. In comparison to dry_run_update this function does not throw an error when the transaction reverts and instead tries to decode the reject reason into a human-readable error. If the dry run succeeds the return value is an object that has a send method to send the transaction that was simulated during the dry run.

The arguments are

• entrypoint the name of the entrypoint to be invoked. Note that this is just the entrypoint name without the contract name.
• amount the amount of CCD to send to the contract instance
• sender the account that will be sending the transaction
• message the parameter to the smart contract entrypoint.

pub async fn dry_run_update_raw<E>( &mut self, entrypoint: &str, amount: Amount, sender: AccountAddress, message: OwnedParameter, ) -> Result<ContractUpdateBuilder, E>

where E: From<NewReceiveNameError> + From<RejectReason> + From<QueryError>,

Like dry_run_update but expects an already formed parameter.

pub async fn dry_run_update_raw_with_reject_reason_info<E>( &mut self, entrypoint: &str, amount: Amount, sender: AccountAddress, message: OwnedParameter, ) -> Result<InvokeContractOutcome, E>

where E: From<NewReceiveNameError> + From<QueryError>,

Like dry_run_update_with_reject_reason_info but expects an already formed parameter.

pub fn make_update<P: Serial, E>( &self, signer: &impl ExactSizeTransactionSigner, metadata: &ContractTransactionMetadata, entrypoint: &str, message: &P, ) -> Result<AccountTransaction<EncodedPayload>, E>

where E: From<NewReceiveNameError> + From<ExceedsParameterSize>,

Make the payload of a contract update with the specified parameter.

pub async fn update<P: Serial, E>( &mut self, signer: &impl ExactSizeTransactionSigner, metadata: &ContractTransactionMetadata, entrypoint: &str, message: &P, ) -> Result<TransactionHash, E>

where E: From<NewReceiveNameError> + From<RPCError> + From<ExceedsParameterSize>,

Make and send a transaction with the specified parameter.

pub async fn update_raw<E>( &mut self, signer: &impl ExactSizeTransactionSigner, metadata: &ContractTransactionMetadata, entrypoint: &str, message: OwnedParameter, ) -> Result<TransactionHash, E>

where E: From<NewReceiveNameError> + From<RPCError>,

Like update but expects a serialized parameter.

pub fn make_update_raw<E>( &self, signer: &impl ExactSizeTransactionSigner, metadata: &ContractTransactionMetadata, entrypoint: &str, message: OwnedParameter, ) -> Result<AccountTransaction<EncodedPayload>, E>

where E: From<NewReceiveNameError>,

Like make_update but expects a serialized parameter.

impl ContractClient<Cis2Type>

pub async fn transfer_dry_run( &mut self, bi: impl IntoBlockIdentifier, sender: Address, transfers: Vec<Transfer>, ) -> Result<Energy, Cis2DryRunError>

Like transfer except it only dry-runs the transaction to get the response and, in case of success, amount of energy used for execution.

Arguments

• bi - The block to dry-run at. The invocation happens at the end of the specified block.
• sender - The address that is invoking the entrypoint.
• transfers - A list of CIS2 token transfers to execute.

pub async fn transfer_single_dry_run( &mut self, bi: impl IntoBlockIdentifier, sender: Address, transfer: Transfer, ) -> Result<Energy, Cis2DryRunError>

Like transfer_dry_run except it is more ergonomic when only a single transfer is to be made.

pub async fn transfer( &mut self, signer: &impl ExactSizeTransactionSigner, transaction_metadata: Cis2TransactionMetadata, transfers: Vec<Transfer>, ) -> Result<TransactionHash, Cis2TransactionError>

Construct and send a CIS2 transfer smart contract update transaction given a list of CIS2 transfers. Returns a Result with the transaction hash.

Arguments

• signer - The account keys to use for signing the smart contract update transaction.
• transaction_metadata - Metadata for constructing the transaction.
• transfers - A list of CIS2 token transfers to execute.

pub fn make_transfer( &self, signer: &impl ExactSizeTransactionSigner, transaction_metadata: Cis2TransactionMetadata, transfers: Vec<Transfer>, ) -> Result<AccountTransaction<EncodedPayload>, Cis2TransactionError>

Construct a CIS2 transfer smart contract update transaction given a list of CIS2 transfers. Returns a Result with an account transaction that can be sent.

Arguments

• signer - The account keys to use for signing the smart contract update transaction.
• transaction_metadata - Metadata for constructing the transaction.
• transfers - A list of CIS2 token transfers to execute.

pub async fn transfer_single( &mut self, signer: &impl ExactSizeTransactionSigner, transaction_metadata: Cis2TransactionMetadata, transfer: Transfer, ) -> Result<TransactionHash, Cis2TransactionError>

Like transfer, except it is more ergonomic when transferring a single token.

pub fn make_transfer_single( &self, signer: &impl ExactSizeTransactionSigner, transaction_metadata: Cis2TransactionMetadata, transfer: Transfer, ) -> Result<AccountTransaction<EncodedPayload>, Cis2TransactionError>

Like make_transfer, except it is more ergonomic when transferring a single token.

pub async fn update_operator_dry_run( &mut self, bi: impl IntoBlockIdentifier, owner: Address, updates: Vec<UpdateOperator>, ) -> Result<Energy, Cis2DryRunError>

Dry run a CIS2 updateOperator transaction. This is analogous to update_operator, except that it does not send a transaction to the chain, and just simulates the transaction.

Arguments

• bi - The block to dry-run at. The invocation happens at the end of
• owner - The address that is invoking. This is the owner of the tokens.
• updates - A list of CIS2 UpdateOperators to update.

pub async fn update_operator_single_dry_run( &mut self, bi: impl IntoBlockIdentifier, owner: Address, operator: Address, update: OperatorUpdate, ) -> Result<Energy, Cis2DryRunError>

Like update_operator_dry_run except more ergonomic when a single operator is to be updated.

pub fn make_update_operator( &self, signer: &impl ExactSizeTransactionSigner, transaction_metadata: Cis2TransactionMetadata, updates: Vec<UpdateOperator>, ) -> Result<AccountTransaction<EncodedPayload>, Cis2TransactionError>

Construct a CIS2 updateOperator smart contract update transaction given a list of CIS2 UpdateOperators. Returns a Result with the account transaction that can be sent.

Arguments

• signer - The account keys to use for signing the smart contract update transaction.
• transaction_metadata - Metadata for constructing the transaction.
• updates - A list of CIS2 UpdateOperators to update.

pub async fn update_operator( &mut self, signer: &impl ExactSizeTransactionSigner, transaction_metadata: Cis2TransactionMetadata, updates: Vec<UpdateOperator>, ) -> Result<TransactionHash, Cis2TransactionError>

Construct and send a CIS2 updateOperator smart contract update transaction given a list of CIS2 UpdateOperators. Returns a Result with the transaction hash.

Arguments

• signer - The account keys to use for signing the smart contract update transaction.
• transaction_metadata - Metadata for constructing the transaction.
• updates - A list of CIS2 UpdateOperators to update.

pub async fn update_operator_single( &mut self, signer: &impl ExactSizeTransactionSigner, transaction_metadata: Cis2TransactionMetadata, operator: Address, update: OperatorUpdate, ) -> Result<TransactionHash, Cis2TransactionError>

Like update_operator, but more ergonomic when updating a single operator.

pub fn make_update_operator_single( &self, signer: &impl ExactSizeTransactionSigner, transaction_metadata: Cis2TransactionMetadata, operator: Address, update: OperatorUpdate, ) -> Result<AccountTransaction<EncodedPayload>, Cis2TransactionError>

Like make_update_operator, but more ergonomic when updating a single operator.

pub async fn balance_of( &mut self, bi: impl IntoBlockIdentifier, queries: Vec<BalanceOfQuery>, ) -> Result<BalanceOfQueryResponse, Cis2QueryError>

Invoke the CIS2 balanceOf query given a list of BalanceOfQuery.

Note: the query is executed locally by the node and does not produce a transaction on-chain.

Arguments

• bi - The block to query. The query will be executed in the state of the chain at the end of the block.
• queries - A list queries to execute.

pub async fn balance_of_single( &mut self, bi: impl IntoBlockIdentifier, token_id: TokenId, address: Address, ) -> Result<TokenAmount, Cis2QueryError>

Like balance_of, except for querying a single token. This additionally ensures that the response has correct length.

pub async fn operator_of( &mut self, bi: impl IntoBlockIdentifier, queries: Vec<OperatorOfQuery>, ) -> Result<OperatorOfQueryResponse, Cis2QueryError>

Invoke the CIS2 operatorOf query given a list of OperatorOfQuery.

Note: the query is executed locally by the node and does not produce a transaction on-chain.

Arguments

• bi - The block to query. The query will be executed in the state of the chain at the end of the block.
• queries - A list queries to execute.

pub async fn operator_of_single( &mut self, bi: impl IntoBlockIdentifier, owner: Address, operator: Address, ) -> Result<bool, Cis2QueryError>

Like operator_of, except for querying a single owner-address pair. This additionally ensures that the response has correct length.

pub async fn token_metadata( &mut self, bi: impl IntoBlockIdentifier, queries: Vec<TokenId>, ) -> Result<TokenMetadataQueryResponse, Cis2QueryError>

Invoke the CIS2 tokenMetadata query given a list of CIS2 TokenIds.

Note: the query is executed locally by the node and does not produce a transaction on-chain.

Arguments

• bi - The block to query. The query will be executed in the state of the chain at the end of the block.
• queries - A list queries to execute.

pub async fn token_metadata_single( &mut self, bi: impl IntoBlockIdentifier, token_id: TokenId, ) -> Result<MetadataUrl, Cis2QueryError>

Like token_metadata, except for querying a single token. This additionally ensures that the response has correct length.

impl ContractClient<Cis3Type>

pub async fn permit_dry_run( &mut self, bi: impl IntoBlockIdentifier, sender: Address, params: PermitParams, ) -> Result<Energy, Cis3PermitDryRunError>

Like permit except it only dry-runs the transaction to get the response and, in case of success, amount of energy used for execution.

Arguments

• bi - The block to query. The query will be executed in the state of the chain at the end of the block.
• sender - The (sponsor) address that is invoking the entrypoint.
• params - The parameters for the permit invocation. Includes the signature of the sponsoree, the address of the sponsoree, and the signed message.

pub async fn permit( &mut self, signer: &impl ExactSizeTransactionSigner, metadata: &ContractTransactionMetadata, params: PermitParams, ) -> Result<TransactionHash, Cis3PermitError>

Construct and send a CIS3 sponsored transaction. This function takes a signature from the sponsoree along with their account address, and the signed message to be executed by the contract. Returns a Result with the transaction hash.

Arguments

• signer - The account keys (of the sponsor) to use for signing the smart contract update transaction.
• metadata - Metadata for constructing the transaction.
• params - The parameters for the permit invocation. Includes the signature of the sponsoree, the address of the sponsoree, and the signed message.

pub fn make_permit( &mut self, signer: &impl ExactSizeTransactionSigner, metadata: &ContractTransactionMetadata, params: PermitParams, ) -> Result<AccountTransaction<EncodedPayload>, Cis3PermitError>

Construct a CIS3 sponsored transaction. This function takes a signature from the sponsoree along with their account address, and the signed message to be executed by the contract. Returns a Result with the transaction hash.

Arguments

• signer - The account keys (of the sponsor) to use for signing the smart contract update transaction.
• metadata - Metadata for constructing the transaction.
• params - The parameters for the permit invocation. Includes the signature of the sponsoree, the address of the sponsoree, and the signed message.

pub async fn supports_permit( &mut self, bi: impl IntoBlockIdentifier, entrypoints: Vec<OwnedEntrypointName>, ) -> Result<SupportsPermitRepsonse, Cis3SupportsPermitError>

Invoke the CIS3 supportsPermit query given a list of entrypoints to query.

Note: the query is executed locally by the node and does not produce a transaction on-chain.

Arguments

• bi - The block to query. The query will be executed in the state of the chain at the end of the block.
• entrypoints - A list queries to execute.

pub async fn supports_permit_single( &mut self, bi: impl IntoBlockIdentifier, entrypoint: OwnedEntrypointName, ) -> Result<bool, Cis3SupportsPermitError>

Like supports_permit, but only queries a single entrypoint, and returns a bool indicating whether the entrypoint is supported.

impl ContractClient<Cis4Type>

pub async fn credential_entry( &mut self, cred_id: CredentialHolderId, bi: impl IntoBlockIdentifier, ) -> Result<CredentialEntry, Cis4QueryError>

Look up an entry in the registry by its id.

pub async fn credential_status( &mut self, cred_id: CredentialHolderId, bi: impl IntoBlockIdentifier, ) -> Result<CredentialStatus, Cis4QueryError>

Look up the status of a credential by its id.

pub async fn revocation_keys( &mut self, bi: impl IntoBlockIdentifier, ) -> Result<Vec<RevocationKeyWithNonce>, Cis4QueryError>

Get the list of all the revocation keys together with their nonces.

pub async fn registry_metadata( &mut self, bi: impl IntoBlockIdentifier, ) -> Result<RegistryMetadata, Cis4QueryError>

Look up the credential registry’s metadata.

pub async fn issuer( &mut self, bi: impl IntoBlockIdentifier, ) -> Result<IssuerKey, Cis4QueryError>

Look up the issuer’s public key.

pub fn make_register_credential( &self, signer: &impl ExactSizeTransactionSigner, metadata: &Cis4TransactionMetadata, cred_info: &CredentialInfo, additional_data: &[u8], ) -> Result<AccountTransaction<EncodedPayload>, Cis4TransactionError>

Construct a transaction for registering a new credential. Note that this does not send the transaction.c

pub async fn register_credential( &mut self, signer: &impl ExactSizeTransactionSigner, metadata: &Cis4TransactionMetadata, cred_info: &CredentialInfo, additional_data: &[u8], ) -> Result<TransactionHash, Cis4TransactionError>

Register a new credential.

pub fn make_revoke_credential_as_issuer( &self, signer: &impl ExactSizeTransactionSigner, metadata: &Cis4TransactionMetadata, cred_id: CredentialHolderId, reason: Option<Reason>, ) -> Result<AccountTransaction<EncodedPayload>, Cis4TransactionError>

Construct a transaction to revoke a credential as an issuer.

pub async fn revoke_credential_as_issuer( &mut self, signer: &impl ExactSizeTransactionSigner, metadata: &Cis4TransactionMetadata, cred_id: CredentialHolderId, reason: Option<Reason>, ) -> Result<TransactionHash, Cis4TransactionError>

Revoke a credential as an issuer.

pub async fn revoke_credential_as_holder( &mut self, signer: &impl ExactSizeTransactionSigner, metadata: &Cis4TransactionMetadata, web3signer: impl Web3IdSigner, nonce: u64, reason: Option<Reason>, ) -> Result<TransactionHash, Cis4TransactionError>

Revoke a credential as the holder.

The extra nonce that must be provided is the holder’s nonce inside the contract. The signature on this revocation message is set to expire at the same time as the transaction.

pub fn make_revoke_credential_as_holder( &self, signer: &impl ExactSizeTransactionSigner, metadata: &Cis4TransactionMetadata, web3signer: impl Web3IdSigner, nonce: u64, reason: Option<Reason>, ) -> Result<AccountTransaction<EncodedPayload>, Cis4TransactionError>

Revoke a credential as the holder.

The extra nonce that must be provided is the holder’s nonce inside the contract. The signature on this revocation message is set to expire at the same time as the transaction.

pub async fn revoke_credential_other( &mut self, signer: &impl ExactSizeTransactionSigner, metadata: &Cis4TransactionMetadata, revoker: impl Web3IdSigner, nonce: u64, cred_id: CredentialHolderId, reason: Option<&Reason>, ) -> Result<TransactionHash, Cis4TransactionError>

Revoke a credential as another party, distinct from issuer or holder.

The extra nonce that must be provided is the nonce associated with the key that signs the revocation message. The signature on this revocation message is set to expire at the same time as the transaction.

pub fn make_revoke_credential_other( &self, signer: &impl ExactSizeTransactionSigner, metadata: &Cis4TransactionMetadata, revoker: impl Web3IdSigner, nonce: u64, cred_id: CredentialHolderId, reason: Option<&Reason>, ) -> Result<AccountTransaction<EncodedPayload>, Cis4TransactionError>

Construct a transaction to revoke a credential as another party, distinct from issuer or holder.

The extra nonce that must be provided is the nonce associated with the key that signs the revocation message. The signature on this revocation message is set to expire at the same time as the transaction.

Trait Implementations

impl<Type> Clone for ContractClient<Type>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Type: Debug> Debug for ContractClient<Type>

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

Formats the value using the given formatter.