[][src]Crate srml_contract

Contract Module

The contract module provides functionality for the runtime to deploy and execute WebAssembly smart-contracts. The supported dispatchable functions are documented as part of the Call enum.

Overview

This module extends accounts (see Balances module) to have smart-contract functionality. These "smart-contract accounts" have the ability to create smart-contracts and make calls to other contract and non-contract accounts.

The smart-contract code is stored once in a code_cache, and later retrievable via its code_hash. This means that multiple smart-contracts can be instantiated from the same code_cache, without replicating the code each time.

When a smart-contract is called, its associated code is retrieved via the code hash and gets executed. This call can alter the storage entries of the smart-contract account, create new smart-contracts, or call other smart-contracts.

Finally, when the Balances module determines an account is dead (i.e. account balance fell below the existential deposit), it reaps the account. This will delete the associated code and storage of the smart-contract account.

Gas

Senders must specify a gas limit with every call, as all instructions invoked by the smart-contract require gas. Unused gas is refunded after the call, regardless of the execution outcome.

If the gas limit is reached, then all calls and state changes (including balance transfers) are only reverted at the current call's contract level. For example, if contract A calls B and B runs out of gas mid-call, then all of B's calls are reverted. Assuming correct error handling by contract A, A's other calls and state changes still persist.

Notable Scenarios

Contract call failures are not always cascading. When failures occur in a sub-call, they do not "bubble up", and the call will only revert at the specific contract level. For example, if contract A calls contract B, and B fails, A can decide how to handle that failure, either proceeding or reverting A's changes.

Interface

Dispatchable functions

Public functions

See the module for details on publicly available functions.

Usage

The contract module is a work in progress. The following examples show how this contract module can be used to create and call contracts.

Macros

convert_args
define_func
gen_signature
gen_signature_dispatch
match_tokens

A simple utility macro that helps to match against a list of tokens.

register_func
unmarshall_then_body_then_marshall

Structs

AccountCounter

The subtrie counter

AccountInfo

Information for managing an acocunt and its sub trie abstraction. This is the required info to cache for an account

AccountInfoOf

The code associated with a given account.

CodeHashOf

The code associated with a given account.

CodeStorage

A mapping between an original code hash and instrumented wasm code, ready for the execution.

Config

In-memory cache of configuration values.

DefaultDispatchFeeComputor

The default dispatch fee computor computes the fee in the same way that implementation of MakePayment for balances module does.

GenesisConfig
Module
PristineCode

A mapping from an original code hash to the original code, untouched by instrumentation.

Schedule

Definition of the cost schedule and other parameterizations for wasm vm.

SimpleAddressDeterminator

Simple contract address determintator.

TrieIdFromParentCounter

Get trie id from account_id

Enums

Call

Contracts module.

RawEvent

Events for this module.

Traits

ComputeDispatchFee

A function that returns the fee for dispatching a Call.

ContractAddressFor

A function that generates an AccountId for a contract upon instantiation.

Trait
TrieIdGenerator

Get a trie id (trie id must be unique and collision resistant depending upon its context) Note that it is different than encode because trie id should have collision resistance property (being a proper uniqueid).

Type Definitions

BalanceOf
CodeHash
Event

RawEvent specialized for the configuration Trait

NegativeImbalanceOf
TrieId