Struct pallet_contracts::pallet::Pallet

pub struct Pallet<T>(_);

The pallet implementing the on-chain logic.

Implementations

impl<T: Config> Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

pub fn call(
    origin: OriginFor<T>,
    dest: <T::Lookup as StaticLookup>::Source,
    value: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    gas_limit: Weight,
    data: Vec<u8>
) -> DispatchResultWithPostInfo

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

• 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(
    origin: OriginFor<T>,
    endowment: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    gas_limit: Weight,
    code: Vec<u8>,
    data: Vec<u8>,
    salt: Vec<u8>
) -> DispatchResultWithPostInfo

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

This is the only function that can deploy new code to the chain.

Parameters

• endowment: The balance to transfer from the origin to the newly created contract.
• gas_limit: The gas limit enforced when executing the constructor.
• 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 endowment is transferred to the new account.
• The deploy function is executed in the context of the newly-created account.

pub fn instantiate(
    origin: OriginFor<T>,
    endowment: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    gas_limit: Weight,
    code_hash: <T as Config>::Hash,
    data: Vec<u8>,
    salt: Vec<u8>
) -> DispatchResultWithPostInfo

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 claim_surcharge(
    origin: OriginFor<T>,
    dest: T::AccountId,
    aux_sender: Option<T::AccountId>
) -> DispatchResultWithPostInfo

Allows block producers to claim a small reward for evicting a contract. If a block producer fails to do so, a regular users will be allowed to claim the reward.

In case of a successful eviction no fees are charged from the sender. However, the reward is capped by the total amount of rent that was paid by the contract while it was alive.

If contract is not evicted as a result of this call, Error::ContractNotEvictable is returned and the sender is not eligible for the reward.

impl<T: Config> Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash> + AsRef<[u8]>, 

pub fn bare_call(
    origin: T::AccountId,
    dest: T::AccountId,
    value: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    gas_limit: Weight,
    input_data: Vec<u8>,
    debug: bool
) -> ContractExecResult

Perform a call to a specified contract.

This function is similar to Self::call, but doesn’t perform any address lookups and better suitable for calling directly from Rust.

Note

debug should only ever be set to true when executing as an RPC because it adds allocations and could be abused to drive the runtime into an OOM panic. If set to true it returns additional human readable debugging information.

It returns the execution result and the amount of used weight.

pub fn bare_instantiate(
    origin: T::AccountId,
    endowment: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    gas_limit: Weight,
    code: Code<<T as Config>::Hash>,
    data: Vec<u8>,
    salt: Vec<u8>,
    compute_projection: bool,
    debug: bool
) -> ContractInstantiateResult<T::AccountId, T::BlockNumber>

Instantiate a new contract.

This function is similar to Self::instantiate, but doesn’t perform any address lookups and better suitable for calling directly from Rust.

It returns the execution result, account id and the amount of used weight.

If compute_projection is set to true the result also contains the rent projection. This is optional because some non trivial and stateful work is performed to compute the projection. See Self::rent_projection.

Note

debug should only ever be set to true when executing as an RPC because it adds allocations and could be abused to drive the runtime into an OOM panic. If set to true it returns additional human readable debugging information.

pub fn get_storage(address: T::AccountId, key: [u8; 32]) -> GetStorageResult

Query storage of a specified contract under a specified key.

pub fn rent_projection(
    address: T::AccountId
) -> RentProjectionResult<T::BlockNumber>

Query how many blocks the contract stays alive given that the amount endowment and consumed storage does not change.

pub fn contract_address(
    deploying_address: &T::AccountId,
    code_hash: &<T as Config>::Hash,
    salt: &[u8]
) -> T::AccountId

Determine the address of a contract,

This is the address generation function used by contract instantiation. Its result is only dependend on its inputs. It can therefore be used to reliably predict the address of a contract. This is akin to the formular of eth’s CREATE2 opcode. There is no CREATE equivalent because CREATE2 is strictly more powerful.

Formula: hash(deploying_address ++ code_hash ++ salt)

pub fn subsistence_threshold(
) -> <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance

Subsistence threshold is the extension of the minimum balance (aka existential deposit) by the tombstone deposit, required for leaving a tombstone.

Rent or any contract initiated balance transfer mechanism cannot make the balance lower than the subsistence threshold in order to guarantee that a tombstone is created.

The only way to completely kill a contract without a tombstone is calling seal_terminate.

pub fn contract_info_size() -> u32

The in-memory size in bytes of the data structure associated with each contract.

The data structure is also put into storage for each contract. The in-storage size is never larger than the in-memory representation and usually smaller due to compact encoding and lack of padding.

Note

This returns the in-memory size because the in-storage size (SCALE encoded) cannot be efficiently determined. Treat this as an upper bound of the in-storage size.

Trait Implementations

impl<T: Config> Benchmarking<BenchmarkResults> for Pallet<T> where
    T: Config,
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

fn benchmarks(extra: bool) -> Vec<BenchmarkMetadata>

Get the benchmarks available for this pallet. Generally there is one benchmark per extrinsic, so these are sometimes just called “extrinsics”.

fn run_benchmark(
    extrinsic: &[u8],
    c: &[(BenchmarkParameter, u32)],
    whitelist: &[TrackedStorageKey],
    verify: bool,
    internal_repeats: u32
) -> Result<Vec<BenchmarkResults>, &'static str>

Run the benchmarks for this pallet.

impl<T: Config> Callable<T> for Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

type Call = Call<T>

impl<T> Clone for Pallet<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Pallet<T>

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

Formats the value using the given formatter.

impl<T: Config> GetStorageVersion for Pallet<T>

fn current_storage_version() -> StorageVersion

Returns the current storage version as supported by the pallet.

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.

impl<T: Config> Hooks<<T as Config>::BlockNumber> for Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

fn on_initialize(_block: T::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

fn on_idle(_n: BlockNumber, _remaining_weight: u64) -> u64

This will be run when the block is being finalized (before on_finalize). Implement to have something happen using the remaining weight. Will not fire if the remaining weight is 0. Return the weight used, the hook will subtract it from current weight used and pass the result to the next on_idle hook if it exists.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a module allows you to perform long-running tasks that make (by default) validators generate transactions that feed results of those long-running computations back on chain.

fn integrity_test()

Run integrity test.

impl<T: Config> IntegrityTest for Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

fn integrity_test()

Run integrity test.

impl<T: Config> ModuleErrorMetadata for Pallet<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Config> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

fn offchain_worker(n: <T as Config>::BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Config> OnFinalize<<T as Config>::BlockNumber> for Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

fn on_finalize(n: <T as Config>::BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Config> OnGenesis for Pallet<T>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config> OnIdle<<T as Config>::BlockNumber> for Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

fn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight

The block is being finalized. Implement to have something happen in case there is leftover weight. Check the passed remaining_weight to make sure it is high enough to allow for your pallet’s extra computation.

impl<T: Config> OnInitialize<<T as Config>::BlockNumber> for Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

fn on_initialize(n: <T as Config>::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

impl<T: Config> OnRuntimeUpgrade for Pallet<T> where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>, 

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade.

impl<T: Config> PalletInfoAccess for Pallet<T>

fn index() -> usize

Index of the pallet as configured in the runtime.

fn name() -> &'static str

Name of the pallet as configured in the runtime.

impl<T> PartialEq<Pallet<T>> for Pallet<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: Config> StorageInfoTrait for Pallet<T>

fn storage_info() -> Vec<StorageInfo>

impl<T> Eq for Pallet<T>