Struct polymesh_api::polymesh::api::contracts::CallApi

pub struct CallApi<'api> { /* private fields */ }

Implementations

impl<'api> CallApi<'api>

pub fn call(
    &self,
    dest: MultiAddress<AccountId, u32>,
    value: u128,
    gas_limit: u64,
    storage_deposit_limit: Option<Compact<u128>>,
    data: Vec<u8>
) -> Result<WrappedCall<'api>>

Makes a call to an account, optionally transferring some balance.

Parameters

• dest: Address of the contract to call.

• value: The balance to transfer from the origin to dest.

• gas_limit: The gas limit enforced when executing the constructor.

• storage_deposit_limit: The maximum amount of balance that can be charged from the caller to pay for the storage consumed.

• data: The input data to pass to the contract.

• If the account is a smart-contract account, the associated code will be executed and any value will be transferred.

• If the account is a regular account, any value will be transferred.

• If no account exists and the call value is not less than existential_deposit, a regular account will be created and any value will be transferred.

pub fn instantiate_with_code(
    &self,
    value: u128,
    gas_limit: u64,
    storage_deposit_limit: Option<Compact<u128>>,
    code: Vec<u8>,
    data: Vec<u8>,
    salt: Vec<u8>
) -> Result<WrappedCall<'api>>

Instantiates a new contract from the supplied code optionally transferring some balance.

This dispatchable has the same effect as calling Self::upload_code + Self::instantiate. Bundling them together provides efficiency gains. Please also check the documentation of Self::upload_code.

Parameters

• value: The balance to transfer from the origin to the newly created contract.
• gas_limit: The gas limit enforced when executing the constructor.
• storage_deposit_limit: The maximum amount of balance that can be charged/reserved from the caller to pay for the storage consumed.
• code: The contract code to deploy in raw bytes.
• data: The input data to pass to the contract constructor.
• salt: Used for the address derivation. See [Pallet::contract_address].

Instantiation is executed as follows:

• The supplied code is instrumented, deployed, and a code_hash is created for that code.
• If the code_hash already exists on the chain the underlying code will be shared.
• The destination address is computed based on the sender, code_hash and the salt.
• The smart-contract account is created at the computed address.
• The value is transferred to the new account.
• The deploy function is executed in the context of the newly-created account.

pub fn instantiate(
    &self,
    value: u128,
    gas_limit: u64,
    storage_deposit_limit: Option<Compact<u128>>,
    code_hash: H256,
    data: Vec<u8>,
    salt: Vec<u8>
) -> Result<WrappedCall<'api>>

Instantiates a contract from a previously deployed wasm binary.

This function is identical to Self::instantiate_with_code but without the code deployment step. Instead, the code_hash of an on-chain deployed wasm binary must be supplied.

pub fn upload_code(
    &self,
    code: Vec<u8>,
    storage_deposit_limit: Option<Compact<u128>>
) -> Result<WrappedCall<'api>>

Upload new code without instantiating a contract from it.

If the code does not already exist a deposit is reserved from the caller and unreserved only when Self::remove_code is called. The size of the reserve depends on the instrumented size of the the supplied code.

If the code already exists in storage it will still return Ok and upgrades the in storage version to the current InstructionWeights::version.

Note

Anyone can instantiate a contract from any uploaded code and thus prevent its removal. To avoid this situation a constructor could employ access control so that it can only be instantiated by permissioned entities. The same is true when uploading through Self::instantiate_with_code.

pub fn remove_code(&self, code_hash: H256) -> Result<WrappedCall<'api>>

Remove the code stored under code_hash and refund the deposit to its owner.

A code can only be removed by its original uploader (its owner) and only if it is not used by any contract.

Trait Implementations

impl<'api> Clone for CallApi<'api>

fn clone(&self) -> CallApi<'api>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'api> From<&'api Api> for CallApi<'api>

fn from(api: &'api Api) -> Self

Converts to this type from the input type.