The Contract module provides functionality for the runtime to deploy and execute WebAssembly smart-contracts.
This module extends accounts based on the
Currency trait to have smart-contract functionality. It can
be used with other modules that implement accounts based on
Currency. 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
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 an account is reaped, its associated code and storage of the smart-contract account will also be deleted.
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.
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.
put_code- Stores the given binary Wasm code into the chain's storage and returns its
create- Deploys a new contract from the given
code_hash, optionally transferring some balance. This creates a new smart contract account and calls its contract deploy handler to initialize the contract.
call- Makes a call to an account, optionally transferring some balance.
The Contract module is a work in progress. The following examples show how this Contract module can be used to create and call contracts.
pDSLis a domain specific language that enables writing WebAssembly based smart contracts in the Rust programming language. This is a work in progress.
A simple utility macro that helps to match against a list of tokens.
The subtrie counter.
A mapping between an original code hash and instrumented wasm code, ready for execution.
In-memory cache of configuration values.
The code associated with a given account.
The default dispatch fee computor computes the fee in the same way that
the implementation of
A mapping from an original code hash to the original code, untouched by instrumentation.
Information for managing an account and its sub trie abstraction. This is the required info to cache for an account.
Definition of the cost schedule and other parameterizations for wasm vm.
Simple contract address determiner.
Get trie id from
Information for managing an acocunt and its sub trie abstraction. This is the required info to cache for an account
Events for this module.
A function that returns the fee for dispatching a
A function that generates an
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 be collision resistant (being a proper unique identifier).