pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 17:01:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Contracts: use compiled rust tests (#2347)

Browse Source 
see #2189

This PR does the following:
- Bring the user api functions into a new pallet-contracts-uapi (They
are currently defined in ink!
[here])(https://github.com/paritytech/ink/blob/master/crates/env/src/engine/on_chain/ext.rs)
- Add older api versions and unstable to the user api trait.
- Remove pallet-contracts-primitives and bring the types it defined in
uapi / pallet-contracts
- Add the infrastructure to build fixtures from Rust files and test it
works by replacing `dummy.wat` and `call.wat`
- Move all the doc from wasm/runtime.rs to pallet-contracts-uapi.

This will be done in a follow up:
- convert the rest of the test from .wat to rust
- bring risc-v uapi up to date with wasm
- finalize the uapi host fns, making sure everything is codegen from the
source host fns in pallet-contracts

---------

Co-authored-by: Alexander Theißen <alex.theissen@me.com>
This commit is contained in:
PG Herveou
2023-11-29 22:12:19 +01:00
committed by GitHub
parent f69069bd42
commit 2135fa872b
38 changed files with 2520 additions and 977 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/contracts/uapi/src/flags.rs
+73
View File
@@ -0,0 +1,73 @@
// This file is part of Substrate.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use bitflags::bitflags;
bitflags! {
/// Flags used by a contract to customize exit behaviour.
#[cfg_attr(feature = "scale", derive(scale::Encode, scale::Decode, scale_info::TypeInfo))]
pub struct ReturnFlags: u32 {
/// If this bit is set all changes made by the contract execution are rolled back.
const REVERT = 0x0000_0001;
}
}
bitflags! {
/// Flags used to change the behaviour of `seal_call` and `seal_delegate_call`.
pub struct CallFlags: u32 {
/// Forward the input of current function to the callee.
///
/// Supplied input pointers are ignored when set.
///
/// # Note
///
/// A forwarding call will consume the current contracts input. Any attempt to
/// access the input after this call returns will lead to [`Error::InputForwarded`].
/// It does not matter if this is due to calling `seal_input` or trying another
/// forwarding call. Consider using [`Self::CLONE_INPUT`] in order to preserve
/// the input.
const FORWARD_INPUT = 0b0000_0001;
/// Identical to [`Self::FORWARD_INPUT`] but without consuming the input.
///
/// This adds some additional weight costs to the call.
///
/// # Note
///
/// This implies [`Self::FORWARD_INPUT`] and takes precedence when both are set.
const CLONE_INPUT = 0b0000_0010;
/// Do not return from the call but rather return the result of the callee to the
/// callers caller.
///
/// # Note
///
/// This makes the current contract completely transparent to its caller by replacing
/// this contracts potential output by the callee ones. Any code after `seal_call`
/// can be safely considered unreachable.
const TAIL_CALL = 0b0000_0100;
/// Allow the callee to reenter into the current contract.
///
/// Without this flag any reentrancy into the current contract that originates from
/// the callee (or any of its callees) is denied. This includes the first callee:
/// You cannot call into yourself with this flag set.
///
/// # Note
///
/// For `seal_delegate_call` should be always unset, otherwise
/// [`Error::InvalidCallFlags`] is returned.
const ALLOW_REENTRY = 0b0000_1000;
}
}
substrate/frame/contracts/uapi/src/host.rs
+793
View File
@@ -0,0 +1,793 @@
// Copyright (C) Parity Technologies (UK) Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use crate::{CallFlags, Result, ReturnFlags, SENTINEL};
use paste::paste;
#[cfg(target_arch = "wasm32")]
mod wasm32;
#[cfg(target_arch = "riscv32")]
mod riscv32;
macro_rules! hash_fn {
( $name:ident, $bytes:literal ) => {
paste! {
#[doc = "Computes the " $name " " $bytes "-bit hash on the given input buffer."]
#[doc = "\n# Notes\n"]
#[doc = "- The `input` and `output` buffer may overlap."]
#[doc = "- The output buffer is expected to hold at least " $bytes " bits."]
#[doc = "- It is the callers responsibility to provide an output buffer that is large enough to hold the expected amount of bytes returned by the hash function."]
#[doc = "\n# Parameters\n"]
#[doc = "- `input`: The input data buffer."]
#[doc = "- `output`: The output buffer to write the hash result to."]
fn [<hash_ $name>](input: &[u8], output: &mut [u8; $bytes]);
}
};
}
fn extract_from_slice(output: &mut &mut [u8], new_len: usize) {
debug_assert!(new_len <= output.len());
let tmp = core::mem::take(output);
*output = &mut tmp[..new_len];
}
fn ptr_len_or_sentinel(data: &mut Option<&mut [u8]>) -> (*mut u8, u32) {
match data {
Some(ref mut data) => (data.as_mut_ptr(), data.len() as _),
None => (SENTINEL as _, 0),
}
}
fn ptr_or_sentinel(data: &Option<&[u8]>) -> *const u8 {
match data {
Some(ref data) => data.as_ptr(),
None => SENTINEL as _,
}
}
/// Implements [`HostFn`] for each supported target architecture.
pub enum HostFnImpl {}
/// Defines all the host apis implemented by both wasm and RISC-V vms.
pub trait HostFn {
/// Returns the number of times specified contract exists on the call stack. Delegated calls are
/// not counted as separate calls.
///
/// # Parameters
///
/// - `account`: The contract address. Should be decodable as an `T::AccountId`. Traps
/// otherwise.
///
/// # Return
///
/// Returns the number of times specified contract exists on the call stack.
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn account_reentrance_count(account: &[u8]) -> u32;
/// Stores the address of the current contract into the supplied buffer.
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the address.
fn address(output: &mut &mut [u8]);
/// Adds a new delegate dependency to the contract.
///
/// Traps if the maximum number of delegate_dependencies is reached or if
/// the delegate dependency already exists.
///
/// # Parameters
///
/// - `code_hash`: The code hash of the dependency. Should be decodable as an `T::Hash`. Traps
/// otherwise.
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn add_delegate_dependency(code_hash: &[u8]);
/// Stores the *free* balance of the current account into the supplied buffer.
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the balance.
fn balance(output: &mut &mut [u8]);
/// Stores the current block number of the current contract into the supplied buffer.
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the block number.
fn block_number(output: &mut &mut [u8]);
/// Make a call to another contract.
///
/// This is equivalent to calling the newer version of this function with
/// `flags` set to [`CallFlags::ALLOW_REENTRY`]. See the newer version for documentation.
#[deprecated(note = "Deprecated, use newer version instead")]
fn call(
callee: &[u8],
gas: u64,
value: &[u8],
input_data: &[u8],
output: Option<&mut [u8]>,
) -> Result;
/// Make a call to another contract.
///
/// Equivalent to the newer [`Self::call_v2`] version but works with
/// *ref_time* Weight only
fn call_v1(
flags: CallFlags,
callee: &[u8],
gas: u64,
value: &[u8],
input_data: &[u8],
output: Option<&mut [u8]>,
) -> Result;
/// Call (possibly transferring some amount of funds) into the specified account.
///
/// # Parameters
///
/// - `flags`: See [`CallFlags`] for a documentation of the supported flags.
/// - `callee`: The address of the callee. Should be decodable as an `T::AccountId`. Traps
/// otherwise.
/// - `ref_time_limit`: how much *ref_time* Weight to devote to the execution.
/// - `proof_size_limit`: how much *proof_size* Weight to devote to the execution.
/// - `deposit`: The storage deposit limit for instantiation. Should be decodable as a
/// `Option<T::Balance>`. Traps otherwise. Passing `None` means setting no specific limit for
/// the call, which implies storage usage up to the limit of the parent call.
/// - `value`: The value to transfer into the contract. Should be decodable as a `T::Balance`.
/// Traps otherwise.
/// - `input`: The input data buffer used to call the contract.
/// - `output`: A reference to the output data buffer to write the call output buffer. If `None`
/// is provided then the output buffer is not copied.
///
/// # Errors
///
/// An error means that the call wasn't successful output buffer is returned unless
/// stated otherwise.
///
/// - [CalleeReverted][`crate::ReturnErrorCode::CalleeReverted]: Output buffer is returned.
/// - [CalleeTrapped][`crate::ReturnErrorCode::CalleeTrapped]
/// - [TransferFailed][`crate::ReturnErrorCode::TransferFailed]
/// - [NotCallable][`crate::ReturnErrorCode::NotCallable]
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn call_v2(
flags: CallFlags,
callee: &[u8],
ref_time_limit: u64,
proof_time_limit: u64,
deposit: Option<&[u8]>,
value: &[u8],
input_data: &[u8],
output: Option<&mut [u8]>,
) -> Result;
/// Call into the chain extension provided by the chain if any.
///
/// Handling of the input values is up to the specific chain extension and so is the
/// return value. The extension can decide to use the inputs as primitive inputs or as
/// in/out arguments by interpreting them as pointers. Any caller of this function
/// must therefore coordinate with the chain that it targets.
///
/// # Note
///
/// If no chain extension exists the contract will trap with the `NoChainExtension`
/// module error.
///
/// # Parameters
///
/// - `func_id`: The function id of the chain extension.
/// - `input`: The input data buffer.
/// - `output`: A reference to the output data buffer to write the output data.
///
/// # Return
///
/// The chain extension returned value, if executed successfully.
fn call_chain_extension(func_id: u32, input: &[u8], output: &mut &mut [u8]) -> u32;
/// Call some dispatchable of the runtime.
///
/// # Parameters
///
/// - `call`: The call data.
///
/// # Return
///
/// Returns `Error::Success` when the dispatchable was successfully executed and
/// returned `Ok`. When the dispatchable was executed but returned an error
/// `Error::CallRuntimeFailed` is returned. The full error is not
/// provided because it is not guaranteed to be stable.
///
/// # Comparison with `ChainExtension`
///
/// Just as a chain extension this API allows the runtime to extend the functionality
/// of contracts. While making use of this function is generally easier it cannot be
/// used in all cases. Consider writing a chain extension if you need to do perform
/// one of the following tasks:
///
/// - Return data.
/// - Provide functionality **exclusively** to contracts.
/// - Provide custom weights.
/// - Avoid the need to keep the `Call` data structure stable.
fn call_runtime(call: &[u8]) -> Result;
/// Stores the address of the caller into the supplied buffer.
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// If this is a top-level call (i.e. initiated by an extrinsic) the origin address of the
/// extrinsic will be returned. Otherwise, if this call is initiated by another contract then
/// the address of the contract will be returned.
///
/// If there is no address associated with the caller (e.g. because the caller is root) then
/// it traps with `BadOrigin`.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the caller address.
fn caller(output: &mut &mut [u8]);
/// Checks whether the caller of the current contract is the origin of the whole call stack.
///
/// Prefer this over [`is_contract()`][`Self::is_contract`] when checking whether your contract
/// is being called by a contract or a plain account. The reason is that it performs better
/// since it does not need to do any storage lookups.
///
/// # Return
///
/// A return value of `true` indicates that this contract is being called by a plain account
/// and `false` indicates that the caller is another contract.
fn caller_is_origin() -> bool;
/// Checks whether the caller of the current contract is root.
///
/// Note that only the origin of the call stack can be root. Hence this function returning
/// `true` implies that the contract is being called by the origin.
///
/// A return value of `true` indicates that this contract is being called by a root origin,
/// and `false` indicates that the caller is a signed origin.
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn caller_is_root() -> u32;
/// Clear the value at the given key in the contract storage.
///
/// Equivalent to the newer [`Self::clear_storage_v1`] version with
/// the exception of the return type. Still a valid thing to call when not interested in the
/// return value.
fn clear_storage(key: &[u8]);
/// Clear the value at the given key in the contract storage.
///
/// # Parameters
///
/// - `key`: The storage key.
///
/// # Return
///
/// Returns the size of the pre-existing value at the specified key if any.
fn clear_storage_v1(key: &[u8]) -> Option<u32>;
/// Retrieve the code hash for a specified contract address.
///
/// # Parameters
///
/// - `account_id`: The address of the contract.Should be decodable as an `T::AccountId`. Traps
/// otherwise.
/// - `output`: A reference to the output data buffer to write the code hash.
///
///
/// # Errors
///
/// - [CodeNotFound][`crate::ReturnErrorCode::CodeNotFound]
fn code_hash(account_id: &[u8], output: &mut [u8]) -> Result;
/// Checks whether there is a value stored under the given key.
///
/// This version is to be used with a fixed sized storage key. For runtimes supporting
/// transparent hashing, please use the newer version of this function.
fn contains_storage(key: &[u8]) -> Option<u32>;
/// Checks whether there is a value stored under the given key.
///
/// The key length must not exceed the maximum defined by the contracts module parameter.
///
/// # Parameters
/// - `key`: The storage key.
///
/// # Return
///
/// Returns the size of the pre-existing value at the specified key if any.
fn contains_storage_v1(key: &[u8]) -> Option<u32>;
/// Execute code in the context (storage, caller, value) of the current contract.
///
/// Reentrancy protection is always disabled since the callee is allowed
/// to modify the callers storage. This makes going through a reentrancy attack
/// unnecessary for the callee when it wants to exploit the caller.
///
/// # Parameters
///
/// - `flags`: See [`CallFlags`] for a documentation of the supported flags.
/// - `code_hash`: The hash of the code to be executed.
/// - `input`: The input data buffer used to call the contract.
/// - `output`: A reference to the output data buffer to write the call output buffer. If `None`
/// is provided then the output buffer is not copied.
///
/// # Errors
///
/// An error means that the call wasn't successful and no output buffer is returned unless
/// stated otherwise.
///
/// - [CalleeReverted][`crate::ReturnErrorCode::CalleeReverted]: Output buffer is returned.
/// - [CalleeTrapped][`crate::ReturnErrorCode::CalleeTrapped]
/// - [CodeNotFound][`crate::ReturnErrorCode::CodeNotFound]
fn delegate_call(
flags: CallFlags,
code_hash: &[u8],
input_data: &[u8],
output: Option<&mut [u8]>,
) -> Result;
/// Deposit a contract event with the data buffer and optional list of topics. There is a limit
/// on the maximum number of topics specified by `event_topics`.
///
/// There should not be any duplicates in `topics`.
///
/// # Parameters
///
/// - `topics`: The topics list encoded as `Vec<T::Hash>`. It can't contain duplicates.
fn deposit_event(topics: &[u8], data: &[u8]);
/// Recovers the ECDSA public key from the given message hash and signature.
///
/// Writes the public key into the given output buffer.
/// Assumes the secp256k1 curve.
///
/// # Parameters
///
/// - `signature`: The signature bytes.
/// - `message_hash`: The message hash bytes.
/// - `output`: A reference to the output data buffer to write the public key.
///
/// # Errors
///
/// - [EcdsaRecoveryFailed][`crate::ReturnErrorCode::EcdsaRecoveryFailed]
fn ecdsa_recover(
signature: &[u8; 65],
message_hash: &[u8; 32],
output: &mut [u8; 33],
) -> Result;
/// Calculates Ethereum address from the ECDSA compressed public key and stores
/// it into the supplied buffer.
///
/// # Parameters
///
/// - `pubkey`: The public key bytes.
/// - `output`: A reference to the output data buffer to write the address.
///
/// # Errors
///
/// - [EcdsaRecoveryFailed][`crate::ReturnErrorCode::EcdsaRecoveryFailed]
fn ecdsa_to_eth_address(pubkey: &[u8; 33], output: &mut [u8; 20]) -> Result;
/// Stores the weight left into the supplied buffer.
///
/// Equivalent to the newer [`Self::gas_left_v1`] version but
/// works with *ref_time* Weight only.
fn gas_left(out: &mut &mut [u8]);
/// Stores the amount of weight left into the supplied buffer.
/// The data is encoded as Weight.
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the weight left.
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn gas_left_v1(output: &mut &mut [u8]);
/// Retrieve the value under the given key from storage.
///
/// This version is to be used with a fixed sized storage key. For runtimes supporting
/// transparent hashing, please use the newer version of this function.
fn get_storage(key: &[u8], output: &mut &mut [u8]) -> Result;
/// Retrieve the value under the given key from storage.
///
/// The key length must not exceed the maximum defined by the contracts module parameter.
///
/// # Parameters
/// - `key`: The storage key.
/// - `output`: A reference to the output data buffer to write the storage entry.
///
/// # Errors
///
/// [KeyNotFound][`crate::ReturnErrorCode::KeyNotFound]
fn get_storage_v1(key: &[u8], output: &mut &mut [u8]) -> Result;
hash_fn!(sha2_256, 32);
hash_fn!(keccak_256, 32);
hash_fn!(blake2_256, 32);
hash_fn!(blake2_128, 16);
/// Stores the input passed by the caller into the supplied buffer.
///
/// # Note
///
/// This function traps if:
/// - the input is larger than the available space.
/// - the input was previously forwarded by a [`call()`][`Self::call()`].
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the input data.
fn input(output: &mut &mut [u8]);
/// Instantiate a contract with the specified code hash.
///
/// Equivalent to the newer [`Self::instantiate_v2`] version but works
/// with *ref_time* Weight only.
fn instantiate_v1(
code_hash: &[u8],
gas: u64,
value: &[u8],
input: &[u8],
address: Option<&mut [u8]>,
output: Option<&mut [u8]>,
salt: &[u8],
) -> Result;
/// Instantiate a contract with the specified code hash.
///
/// This function creates an account and executes the constructor defined in the code specified
/// by the code hash.
///
/// # Parameters
///
/// - `code_hash`: The hash of the code to be instantiated.
/// - `ref_time_limit`: how much *ref_time* Weight to devote to the execution.
/// - `proof_size_limit`: how much *proof_size* Weight to devote to the execution.
/// - `deposit`: The storage deposit limit for instantiation. Should be decodable as a
/// `Option<T::Balance>`. Traps otherwise. Passing `None` means setting no specific limit for
/// the call, which implies storage usage up to the limit of the parent call.
/// - `value`: The value to transfer into the contract. Should be decodable as a `T::Balance`.
/// Traps otherwise.
/// - `input`: The input data buffer.
/// - `address`: A reference to the address buffer to write the address of the contract. If
/// `None` is provided then the output buffer is not copied.
/// - `output`: A reference to the return value buffer to write the constructor output buffer.
/// If `None` is provided then the output buffer is not copied.
/// - `salt`: The salt bytes to use for this instantiation.
///
/// # Errors
///
/// Please consult the [ReturnErrorCode][`crate::ReturnErrorCode`] enum declaration for more
/// information on those errors. Here we only note things specific to this function.
///
/// An error means that the account wasn't created and no address or output buffer
/// is returned unless stated otherwise.
///
/// - [CalleeReverted][`crate::ReturnErrorCode::CalleeReverted]: Output buffer is returned.
/// - [CalleeTrapped][`crate::ReturnErrorCode::CalleeTrapped]
/// - [TransferFailed][`crate::ReturnErrorCode::TransferFailed]
/// - [CodeNotFound][`crate::ReturnErrorCode::CodeNotFound]
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn instantiate_v2(
code_hash: &[u8],
ref_time_limit: u64,
proof_size_limit: u64,
deposit: Option<&[u8]>,
value: &[u8],
input: &[u8],
address: Option<&mut [u8]>,
output: Option<&mut [u8]>,
salt: &[u8],
) -> Result;
/// Returns a nonce that is unique per contract instantiation.
///
/// The nonce is incremented for each successful contract instantiation. This is a
/// sensible default salt for contract instantiations.
fn instantiation_nonce() -> u64;
/// Checks whether a specified address belongs to a contract.
///
/// # Parameters
///
/// - `account_id`: The address to check. Should be decodable as an `T::AccountId`. Traps
/// otherwise.
///
/// # Return
///
/// Returns `true` if the address belongs to a contract.
fn is_contract(account_id: &[u8]) -> bool;
/// Stores the minimum balance (a.k.a. existential deposit) into the supplied buffer.
/// The data is encoded as `T::Balance`.
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the minimum balance.
fn minimum_balance(output: &mut &mut [u8]);
/// Retrieve the code hash of the currently executing contract.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the code hash.
fn own_code_hash(output: &mut [u8]);
/// Load the latest block timestamp into the supplied buffer
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the timestamp.
fn now(output: &mut &mut [u8]);
/// Returns the number of times the currently executing contract exists on the call stack in
/// addition to the calling instance.
///
/// # Return
///
/// Returns `0` when there is no reentrancy.
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn reentrance_count() -> u32;
/// Removes the delegate dependency from the contract.
///
/// Traps if the delegate dependency does not exist.
///
/// # Parameters
///
/// - `code_hash`: The code hash of the dependency. Should be decodable as an `T::Hash`. Traps
/// otherwise.
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn remove_delegate_dependency(code_hash: &[u8]);
/// Cease contract execution and save a data buffer as a result of the execution.
///
/// This function never returns as it stops execution of the caller.
/// This is the only way to return a data buffer to the caller. Returning from
/// execution without calling this function is equivalent to calling:
/// ```nocompile
/// return_value(ReturnFlags::empty(), &[])
/// ```
///
/// Using an unnamed non empty `ReturnFlags` triggers a trap.
///
/// # Parameters
///
/// - `flags`: Flag used to signal special return conditions to the supervisor. See
/// [`ReturnFlags`] for a documentation of the supported flags.
/// - `return_value`: The return value buffer.
fn return_value(flags: ReturnFlags, return_value: &[u8]) -> !;
/// Replace the contract code at the specified address with new code.
///
/// # Note
///
/// There are a couple of important considerations which must be taken into account when
/// using this API:
///
/// 1. The storage at the code address will remain untouched. This means that contract
/// developers must ensure that the storage layout of the new code is compatible with that of
/// the old code.
///
/// 2. Contracts using this API can't be assumed as having deterministic addresses. Said another
/// way, when using this API you lose the guarantee that an address always identifies a specific
/// code hash.
///
/// 3. If a contract calls into itself after changing its code the new call would use
/// the new code. However, if the original caller panics after returning from the sub call it
/// would revert the changes made by [`set_code_hash()`][`Self::set_code_hash`] and the next
/// caller would use the old code.
///
/// # Parameters
///
/// - `code_hash`: The hash of the new code. Should be decodable as an `T::Hash`. Traps
/// otherwise.
///
/// # Errors
///
/// - [CodeNotFound][`crate::ReturnErrorCode::CodeNotFound]
fn set_code_hash(code_hash: &[u8]) -> Result;
/// Set the value at the given key in the contract storage.
///
/// Equivalent to [`Self::set_storage_v1`] version with the
/// exception of the return type. Still a valid thing to call for fixed sized storage key, when
/// not interested in the return value.
fn set_storage(key: &[u8], value: &[u8]);
/// Set the value at the given key in the contract storage.
///
/// This version is to be used with a fixed sized storage key. For runtimes supporting
/// transparent hashing, please use the newer version of this function.
fn set_storage_v1(key: &[u8], value: &[u8]) -> Option<u32>;
/// Set the value at the given key in the contract storage.
///
/// The key and value lengths must not exceed the maximums defined by the contracts module
/// parameters.
///
/// # Parameters
///
/// - `key`: The storage key.
/// - `encoded_value`: The storage value.
///
/// # Return
///
/// Returns the size of the pre-existing value at the specified key if any.
fn set_storage_v2(key: &[u8], value: &[u8]) -> Option<u32>;
/// Verify a sr25519 signature
///
/// # Parameters
///
/// - `signature`: The signature bytes.
/// - `message`: The message bytes.
///
/// # Errors
///
/// - [Sr25519VerifyFailed][`crate::ReturnErrorCode::Sr25519VerifyFailed]
fn sr25519_verify(signature: &[u8; 64], message: &[u8], pub_key: &[u8; 32]) -> Result;
/// Retrieve and remove the value under the given key from storage.
///
/// # Parameters
/// - `key`: The storage key.
/// - `output`: A reference to the output data buffer to write the storage entry.
///
/// # Errors
///
/// [KeyNotFound][`crate::ReturnErrorCode::KeyNotFound]
fn take_storage(key: &[u8], output: &mut &mut [u8]) -> Result;
/// Transfer some amount of funds into the specified account.
///
/// # Parameters
///
/// - `account_id`: The address of the account to transfer funds to. Should be decodable as an
/// `T::AccountId`. Traps otherwise.
/// - `value`: The value to transfer. Should be decodable as a `T::Balance`. Traps otherwise.
///
/// # Errors
///
/// - [TransferFailed][`crate::ReturnErrorCode::TransferFailed]
fn transfer(account_id: &[u8], value: &[u8]) -> Result;
/// Remove the calling account and transfer remaining balance.
///
/// This is equivalent to calling the newer version of this function
#[deprecated(note = "Deprecated, use newer version instead")]
fn terminate(beneficiary: &[u8]) -> !;
/// Remove the calling account and transfer remaining **free** balance.
///
/// This function never returns. Either the termination was successful and the
/// execution of the destroyed contract is halted. Or it failed during the termination
/// which is considered fatal and results in a trap + rollback.
///
/// # Parameters
///
/// - `beneficiary`: The address of the beneficiary account, Should be decodable as an
/// `T::AccountId`.
///
/// # Traps
///
/// - The contract is live i.e is already on the call stack.
/// - Failed to send the balance to the beneficiary.
/// - The deletion queue is full.
fn terminate_v1(beneficiary: &[u8]) -> !;
/// Stores the value transferred along with this call/instantiate into the supplied buffer.
/// The data is encoded as `T::Balance`.
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// # Parameters
///
/// - `output`: A reference to the output data buffer to write the transferred value.
fn value_transferred(output: &mut &mut [u8]);
/// Stores the price for the specified amount of gas into the supplied buffer.
///
/// Equivalent to the newer [`Self::weight_to_fee_v1`] version but
/// works with *ref_time* Weight only. It is recommended to switch to the latest version, once
/// it's stabilized.
fn weight_to_fee(gas: u64, output: &mut &mut [u8]);
/// Stores the price for the specified amount of gas into the supplied buffer.
/// The data is encoded as `T::Balance`.
///
/// If the available space in `output` is less than the size of the value a trap is triggered.
///
/// # Parameters
///
/// - `ref_time_limit`: The *ref_time* Weight limit to query the price for.
/// - `proof_size_limit`: The *proof_size* Weight limit to query the price for.
/// - `output`: A reference to the output data buffer to write the price.
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn weight_to_fee_v1(ref_time_limit: u64, proof_size_limit: u64, output: &mut &mut [u8]);
/// Execute an XCM program locally, using the contract's address as the origin.
/// This is equivalent to dispatching `pallet_xcm::execute` through call_runtime, except that
/// the function is called directly instead of being dispatched.
///
/// # Parameters
///
/// - `msg`: The message, should be decodable as a [VersionedXcm](https://paritytech.github.io/polkadot-sdk/master/staging_xcm/enum.VersionedXcm.html),
/// traps otherwise.
/// - `output`: A reference to the output data buffer to write the [Outcome](https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v3/enum.Outcome.html)
///
/// # Return
///
/// Returns `Error::Success` when the XCM execution attempt is successful. When the XCM
/// execution fails, `ReturnCode::XcmExecutionFailed` is returned
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn xcm_execute(msg: &[u8], output: &mut &mut [u8]) -> Result;
/// Send an XCM program from the contract to the specified destination.
/// This is equivalent to dispatching `pallet_xcm::send` through `call_runtime`, except that
/// the function is called directly instead of being dispatched.
///
/// # Parameters
///
/// - `dest`: The XCM destination, should be decodable as [VersionedMultiLocation](https://paritytech.github.io/polkadot-sdk/master/staging_xcm/enum.VersionedMultiLocation.html),
/// traps otherwise.
/// - `msg`: The message, should be decodable as a [VersionedXcm](https://paritytech.github.io/polkadot-sdk/master/staging_xcm/enum.VersionedXcm.html),
/// traps otherwise.
/// - `output`: A reference to the output data buffer to write the [XcmHash](https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v3/type.XcmHash.html)
///
/// # Return
///
/// Returns `ReturnCode::Success` when the message was successfully sent. When the XCM
/// execution fails, `ReturnErrorCode::XcmSendFailed` is returned.
#[deprecated(
note = "Unstable function. Behaviour can change without further notice. Use only for testing."
)]
fn xcm_send(dest: &[u8], msg: &[u8], output: &mut &mut [u8]) -> Result;
}
substrate/frame/contracts/uapi/src/host/riscv32.rs
+14
View File
@@ -0,0 +1,14 @@
// Copyright (C) Parity Technologies (UK) Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// TODO: bring up to date with wasm32.rs
substrate/frame/contracts/uapi/src/host/wasm32.rs
+811
View File
@@ -0,0 +1,811 @@
// Copyright (C) Parity Technologies (UK) Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use super::{
extract_from_slice, ptr_len_or_sentinel, ptr_or_sentinel, CallFlags, HostFn, HostFnImpl, Result,
};
use crate::{ReturnCode, ReturnFlags};
mod sys {
use super::ReturnCode;
#[link(wasm_import_module = "seal0")]
extern "C" {
pub fn account_reentrance_count(account_ptr: *const u8) -> u32;
pub fn add_delegate_dependency(code_hash_ptr: *const u8);
pub fn address(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn balance(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn block_number(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn call(
callee_ptr: *const u8,
callee_len: u32,
gas: u64,
value_ptr: *const u8,
value_len: u32,
input_data_ptr: *const u8,
input_data_len: u32,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
) -> ReturnCode;
pub fn call_chain_extension(
func_id: u32,
input_ptr: *const u8,
input_len: u32,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
) -> ReturnCode;
pub fn call_runtime(call_ptr: *const u8, call_len: u32) -> ReturnCode;
pub fn caller(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn caller_is_origin() -> ReturnCode;
pub fn caller_is_root() -> ReturnCode;
pub fn clear_storage(key_ptr: *const u8, key_len: u32) -> ReturnCode;
pub fn code_hash(
account_id_ptr: *const u8,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
) -> ReturnCode;
pub fn contains_storage(key_ptr: *const u8, key_len: u32) -> ReturnCode;
pub fn delegate_call(
flags: u32,
code_hash_ptr: *const u8,
input_data_ptr: *const u8,
input_data_len: u32,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
) -> ReturnCode;
pub fn deposit_event(
topics_ptr: *const u8,
topics_len: u32,
data_ptr: *const u8,
data_len: u32,
);
pub fn ecdsa_recover(
signature_ptr: *const u8,
message_hash_ptr: *const u8,
output_ptr: *mut u8,
) -> ReturnCode;
pub fn ecdsa_to_eth_address(public_key_ptr: *const u8, output_ptr: *mut u8) -> ReturnCode;
pub fn gas_left(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn get_storage(
key_ptr: *const u8,
key_len: u32,
out_ptr: *mut u8,
out_len_ptr: *mut u32,
) -> ReturnCode;
pub fn hash_blake2_128(input_ptr: *const u8, input_len: u32, output_ptr: *mut u8);
pub fn hash_blake2_256(input_ptr: *const u8, input_len: u32, output_ptr: *mut u8);
pub fn hash_keccak_256(input_ptr: *const u8, input_len: u32, output_ptr: *mut u8);
pub fn hash_sha2_256(input_ptr: *const u8, input_len: u32, output_ptr: *mut u8);
pub fn input(buf_ptr: *mut u8, buf_len_ptr: *mut u32);
pub fn instantiation_nonce() -> u64;
pub fn is_contract(account_id_ptr: *const u8) -> ReturnCode;
pub fn minimum_balance(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn now(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn own_code_hash(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn reentrance_count() -> u32;
pub fn remove_delegate_dependency(code_hash_ptr: *const u8);
pub fn seal_return(flags: u32, data_ptr: *const u8, data_len: u32) -> !;
pub fn set_code_hash(code_hash_ptr: *const u8) -> ReturnCode;
pub fn set_storage(
key_ptr: *const u8,
key_len: u32,
value_ptr: *const u8,
value_len: u32,
) -> ReturnCode;
pub fn sr25519_verify(
signature_ptr: *const u8,
public_key_ptr: *const u8,
message_len: u32,
message_ptr: *const u8,
) -> ReturnCode;
pub fn take_storage(
key_ptr: *const u8,
key_len: u32,
out_ptr: *mut u8,
out_len_ptr: *mut u32,
) -> ReturnCode;
pub fn terminate(beneficiary_ptr: *const u8) -> !;
pub fn transfer(
account_id_ptr: *const u8,
account_id_len: u32,
transferred_value_ptr: *const u8,
transferred_value_len: u32,
) -> ReturnCode;
pub fn value_transferred(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn weight_to_fee(gas: u64, output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn xcm_execute(msg_ptr: *const u8, msg_len: u32, output_ptr: *mut u8) -> ReturnCode;
pub fn xcm_send(
dest_ptr: *const u8,
msg_ptr: *const u8,
msg_len: u32,
output_ptr: *mut u8,
) -> ReturnCode;
}
pub mod v1 {
use crate::ReturnCode;
#[link(wasm_import_module = "seal1")]
extern "C" {
pub fn call(
flags: u32,
callee_ptr: *const u8,
gas: u64,
transferred_value_ptr: *const u8,
input_data_ptr: *const u8,
input_data_len: u32,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
) -> ReturnCode;
pub fn clear_storage(key_ptr: *const u8, key_len: u32) -> ReturnCode;
pub fn contains_storage(key_ptr: *const u8, key_len: u32) -> ReturnCode;
pub fn gas_left(output_ptr: *mut u8, output_len_ptr: *mut u32);
pub fn get_storage(
key_ptr: *const u8,
key_len: u32,
out_ptr: *mut u8,
out_len_ptr: *mut u32,
) -> ReturnCode;
pub fn instantiate(
code_hash_ptr: *const u8,
gas: u64,
value_ptr: *const u8,
input_ptr: *const u8,
input_len: u32,
address_ptr: *mut u8,
address_len_ptr: *mut u32,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
salt_ptr: *const u8,
salt_len: u32,
) -> ReturnCode;
pub fn set_storage(
key_ptr: *const u8,
key_len: u32,
value_ptr: *const u8,
value_len: u32,
) -> ReturnCode;
pub fn terminate(beneficiary_ptr: *const u8) -> !;
pub fn weight_to_fee(
ref_time_limit: u64,
proof_time_limit: u64,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
);
}
}
pub mod v2 {
use crate::ReturnCode;
#[link(wasm_import_module = "seal2")]
extern "C" {
pub fn call(
flags: u32,
callee_ptr: *const u8,
ref_time_limit: u64,
proof_time_limit: u64,
deposit_ptr: *const u8,
transferred_value_ptr: *const u8,
input_data_ptr: *const u8,
input_data_len: u32,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
) -> ReturnCode;
pub fn instantiate(
code_hash_ptr: *const u8,
ref_time_limit: u64,
proof_time_limit: u64,
deposit_ptr: *const u8,
value_ptr: *const u8,
input_ptr: *const u8,
input_len: u32,
address_ptr: *mut u8,
address_len_ptr: *mut u32,
output_ptr: *mut u8,
output_len_ptr: *mut u32,
salt_ptr: *const u8,
salt_len: u32,
) -> ReturnCode;
pub fn set_storage(
key_ptr: *const u8,
key_len: u32,
value_ptr: *const u8,
value_len: u32,
) -> ReturnCode;
}
}
}
/// A macro to implement all Host functions with a signature of `fn(&mut &mut [u8])`.
macro_rules! impl_wrapper_for {
(@impl_fn $( $mod:ident )::*, $suffix:literal, $name:ident) => {
paste::paste! {
fn [<$name $suffix>](output: &mut &mut [u8]) {
let mut output_len = output.len() as u32;
unsafe {
$( $mod )::*::$name(output.as_mut_ptr(), &mut output_len);
}
}
}
};
() => {};
(($mod:ident, $suffix:literal) => [$( $name:ident),*], $($tail:tt)*) => {
$(impl_wrapper_for!(@impl_fn sys::$mod, $suffix, $name);)*
impl_wrapper_for!($($tail)*);
};
(() => [$( $name:ident),*], $($tail:tt)*) => {
$(impl_wrapper_for!(@impl_fn sys, "", $name);)*
impl_wrapper_for!($($tail)*);
};
}
/// A macro to implement all the hash functions Apis.
macro_rules! impl_hash_fn {
( $name:ident, $bytes_result:literal ) => {
paste::item! {
fn [<hash_ $name>](input: &[u8], output: &mut [u8; $bytes_result]) {
unsafe {
sys::[<hash_ $name>](
input.as_ptr(),
input.len() as u32,
output.as_mut_ptr(),
)
}
}
}
};
}
/// A macro to implement the get_storage functions.
macro_rules! impl_get_storage {
($fn_name:ident, $sys_get_storage:path) => {
fn $fn_name(key: &[u8], output: &mut &mut [u8]) -> Result {
let mut output_len = output.len() as u32;
let ret_code = {
unsafe {
$sys_get_storage(
key.as_ptr(),
key.len() as u32,
output.as_mut_ptr(),
&mut output_len,
)
}
};
extract_from_slice(output, output_len as usize);
ret_code.into()
}
};
}
impl HostFn for HostFnImpl {
fn instantiate_v1(
code_hash: &[u8],
gas: u64,
value: &[u8],
input: &[u8],
mut address: Option<&mut [u8]>,
mut output: Option<&mut [u8]>,
salt: &[u8],
) -> Result {
let (address_ptr, mut address_len) = ptr_len_or_sentinel(&mut address);
let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
let ret_code = unsafe {
sys::v1::instantiate(
code_hash.as_ptr(),
gas,
value.as_ptr(),
input.as_ptr(),
input.len() as u32,
address_ptr,
&mut address_len,
output_ptr,
&mut output_len,
salt.as_ptr(),
salt.len() as u32,
)
};
if let Some(ref mut address) = address {
extract_from_slice(address, address_len as usize);
}
if let Some(ref mut output) = output {
extract_from_slice(output, output_len as usize);
}
ret_code.into()
}
fn instantiate_v2(
code_hash: &[u8],
ref_time_limit: u64,
proof_size_limit: u64,
deposit: Option<&[u8]>,
value: &[u8],
input: &[u8],
mut address: Option<&mut [u8]>,
mut output: Option<&mut [u8]>,
salt: &[u8],
) -> Result {
let (address_ptr, mut address_len) = ptr_len_or_sentinel(&mut address);
let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
let deposit_ptr = ptr_or_sentinel(&deposit);
let ret_code = {
unsafe {
sys::v2::instantiate(
code_hash.as_ptr(),
ref_time_limit,
proof_size_limit,
deposit_ptr,
value.as_ptr(),
input.as_ptr(),
input.len() as u32,
address_ptr,
&mut address_len,
output_ptr,
&mut output_len,
salt.as_ptr(),
salt.len() as u32,
)
}
};
if let Some(ref mut address) = address {
extract_from_slice(address, address_len as usize);
}
if let Some(ref mut output) = output {
extract_from_slice(output, output_len as usize);
}
ret_code.into()
}
fn call(
callee: &[u8],
gas: u64,
value: &[u8],
input_data: &[u8],
mut output: Option<&mut [u8]>,
) -> Result {
let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
let ret_code = {
unsafe {
sys::call(
callee.as_ptr(),
callee.len() as u32,
gas,
value.as_ptr(),
value.len() as u32,
input_data.as_ptr(),
input_data.len() as u32,
output_ptr,
&mut output_len,
)
}
};
if let Some(ref mut output) = output {
extract_from_slice(output, output_len as usize);
}
ret_code.into()
}
fn call_v1(
flags: CallFlags,
callee: &[u8],
gas: u64,
value: &[u8],
input_data: &[u8],
mut output: Option<&mut [u8]>,
) -> Result {
let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
let ret_code = {
unsafe {
sys::v1::call(
flags.bits(),
callee.as_ptr(),
gas,
value.as_ptr(),
input_data.as_ptr(),
input_data.len() as u32,
output_ptr,
&mut output_len,
)
}
};
if let Some(ref mut output) = output {
extract_from_slice(output, output_len as usize);
}
ret_code.into()
}
fn call_v2(
flags: CallFlags,
callee: &[u8],
ref_time_limit: u64,
proof_time_limit: u64,
deposit: Option<&[u8]>,
value: &[u8],
input_data: &[u8],
mut output: Option<&mut [u8]>,
) -> Result {
let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
let deposit_ptr = ptr_or_sentinel(&deposit);
let ret_code = {
unsafe {
sys::v2::call(
flags.bits(),
callee.as_ptr(),
ref_time_limit,
proof_time_limit,
deposit_ptr,
value.as_ptr(),
input_data.as_ptr(),
input_data.len() as u32,
output_ptr,
&mut output_len,
)
}
};
if let Some(ref mut output) = output {
extract_from_slice(output, output_len as usize);
}
ret_code.into()
}
fn caller_is_root() -> u32 {
unsafe { sys::caller_is_root() }.into_u32()
}
fn delegate_call(
flags: CallFlags,
code_hash: &[u8],
input: &[u8],
mut output: Option<&mut [u8]>,
) -> Result {
let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
let ret_code = {
unsafe {
sys::delegate_call(
flags.bits(),
code_hash.as_ptr(),
input.as_ptr(),
input.len() as u32,
output_ptr,
&mut output_len,
)
}
};
if let Some(ref mut output) = output {
extract_from_slice(output, output_len as usize);
}
ret_code.into()
}
fn transfer(account_id: &[u8], value: &[u8]) -> Result {
let ret_code = unsafe {
sys::transfer(
account_id.as_ptr(),
account_id.len() as u32,
value.as_ptr(),
value.len() as u32,
)
};
ret_code.into()
}
fn deposit_event(topics: &[u8], data: &[u8]) {
unsafe {
sys::deposit_event(
topics.as_ptr(),
topics.len() as u32,
data.as_ptr(),
data.len() as u32,
)
}
}
fn set_storage(key: &[u8], value: &[u8]) {
unsafe {
sys::set_storage(key.as_ptr(), key.len() as u32, value.as_ptr(), value.len() as u32)
};
}
fn set_storage_v1(key: &[u8], encoded_value: &[u8]) -> Option<u32> {
let ret_code = unsafe {
sys::v1::set_storage(
key.as_ptr(),
key.len() as u32,
encoded_value.as_ptr(),
encoded_value.len() as u32,
)
};
ret_code.into()
}
fn set_storage_v2(key: &[u8], encoded_value: &[u8]) -> Option<u32> {
let ret_code = unsafe {
sys::v2::set_storage(
key.as_ptr(),
key.len() as u32,
encoded_value.as_ptr(),
encoded_value.len() as u32,
)
};
ret_code.into()
}
fn clear_storage(key: &[u8]) {
unsafe { sys::clear_storage(key.as_ptr(), key.len() as u32) };
}
fn clear_storage_v1(key: &[u8]) -> Option<u32> {
let ret_code = unsafe { sys::v1::clear_storage(key.as_ptr(), key.len() as u32) };
ret_code.into()
}
impl_get_storage!(get_storage, sys::get_storage);
impl_get_storage!(get_storage_v1, sys::v1::get_storage);
fn take_storage(key: &[u8], output: &mut &mut [u8]) -> Result {
let mut output_len = output.len() as u32;
let ret_code = {
unsafe {
sys::take_storage(
key.as_ptr(),
key.len() as u32,
output.as_mut_ptr(),
&mut output_len,
)
}
};
extract_from_slice(output, output_len as usize);
ret_code.into()
}
fn contains_storage(key: &[u8]) -> Option<u32> {
let ret_code = unsafe { sys::contains_storage(key.as_ptr(), key.len() as u32) };
ret_code.into()
}
fn contains_storage_v1(key: &[u8]) -> Option<u32> {
let ret_code = unsafe { sys::v1::contains_storage(key.as_ptr(), key.len() as u32) };
ret_code.into()
}
fn terminate(beneficiary: &[u8]) -> ! {
unsafe { sys::terminate(beneficiary.as_ptr()) }
}
fn terminate_v1(beneficiary: &[u8]) -> ! {
unsafe { sys::v1::terminate(beneficiary.as_ptr()) }
}
fn call_chain_extension(func_id: u32, input: &[u8], output: &mut &mut [u8]) -> u32 {
let mut output_len = output.len() as u32;
let ret_code = {
unsafe {
sys::call_chain_extension(
func_id,
input.as_ptr(),
input.len() as u32,
output.as_mut_ptr(),
&mut output_len,
)
}
};
extract_from_slice(output, output_len as usize);
ret_code.into_u32()
}
fn input(output: &mut &mut [u8]) {
let mut output_len = output.len() as u32;
{
unsafe { sys::input(output.as_mut_ptr(), &mut output_len) };
}
extract_from_slice(output, output_len as usize);
}
fn return_value(flags: ReturnFlags, return_value: &[u8]) -> ! {
unsafe { sys::seal_return(flags.bits(), return_value.as_ptr(), return_value.len() as u32) }
}
fn call_runtime(call: &[u8]) -> Result {
let ret_code = unsafe { sys::call_runtime(call.as_ptr(), call.len() as u32) };
ret_code.into()
}
impl_wrapper_for! {
() => [caller, block_number, address, balance, gas_left, value_transferred, now, minimum_balance],
(v1, "_v1") => [gas_left],
}
fn weight_to_fee(gas: u64, output: &mut &mut [u8]) {
let mut output_len = output.len() as u32;
{
unsafe { sys::weight_to_fee(gas, output.as_mut_ptr(), &mut output_len) };
}
extract_from_slice(output, output_len as usize);
}
fn weight_to_fee_v1(ref_time_limit: u64, proof_size_limit: u64, output: &mut &mut [u8]) {
let mut output_len = output.len() as u32;
{
unsafe {
sys::v1::weight_to_fee(
ref_time_limit,
proof_size_limit,
output.as_mut_ptr(),
&mut output_len,
)
};
}
extract_from_slice(output, output_len as usize);
}
impl_hash_fn!(sha2_256, 32);
impl_hash_fn!(keccak_256, 32);
impl_hash_fn!(blake2_256, 32);
impl_hash_fn!(blake2_128, 16);
fn ecdsa_recover(
signature: &[u8; 65],
message_hash: &[u8; 32],
output: &mut [u8; 33],
) -> Result {
let ret_code = unsafe {
sys::ecdsa_recover(signature.as_ptr(), message_hash.as_ptr(), output.as_mut_ptr())
};
ret_code.into()
}
fn ecdsa_to_eth_address(pubkey: &[u8; 33], output: &mut [u8; 20]) -> Result {
let ret_code = unsafe { sys::ecdsa_to_eth_address(pubkey.as_ptr(), output.as_mut_ptr()) };
ret_code.into()
}
fn sr25519_verify(signature: &[u8; 64], message: &[u8], pub_key: &[u8; 32]) -> Result {
let ret_code = unsafe {
sys::sr25519_verify(
signature.as_ptr(),
pub_key.as_ptr(),
message.len() as u32,
message.as_ptr(),
)
};
ret_code.into()
}
fn is_contract(account_id: &[u8]) -> bool {
let ret_val = unsafe { sys::is_contract(account_id.as_ptr()) };
ret_val.into_bool()
}
fn caller_is_origin() -> bool {
let ret_val = unsafe { sys::caller_is_origin() };
ret_val.into_bool()
}
fn set_code_hash(code_hash: &[u8]) -> Result {
let ret_val = unsafe { sys::set_code_hash(code_hash.as_ptr()) };
ret_val.into()
}
fn code_hash(account_id: &[u8], output: &mut [u8]) -> Result {
let mut output_len = output.len() as u32;
let ret_val =
unsafe { sys::code_hash(account_id.as_ptr(), output.as_mut_ptr(), &mut output_len) };
ret_val.into()
}
fn own_code_hash(output: &mut [u8]) {
let mut output_len = output.len() as u32;
unsafe { sys::own_code_hash(output.as_mut_ptr(), &mut output_len) }
}
fn account_reentrance_count(account: &[u8]) -> u32 {
unsafe { sys::account_reentrance_count(account.as_ptr()) }
}
fn add_delegate_dependency(code_hash: &[u8]) {
unsafe { sys::add_delegate_dependency(code_hash.as_ptr()) }
}
fn remove_delegate_dependency(code_hash: &[u8]) {
unsafe { sys::remove_delegate_dependency(code_hash.as_ptr()) }
}
fn instantiation_nonce() -> u64 {
unsafe { sys::instantiation_nonce() }
}
fn reentrance_count() -> u32 {
unsafe { sys::reentrance_count() }
}
fn xcm_execute(msg: &[u8], output: &mut &mut [u8]) -> Result {
let ret_code =
unsafe { sys::xcm_execute(msg.as_ptr(), msg.len() as _, output.as_mut_ptr()) };
ret_code.into()
}
fn xcm_send(dest: &[u8], msg: &[u8], output: &mut &mut [u8]) -> Result {
let ret_code = unsafe {
sys::xcm_send(dest.as_ptr(), msg.as_ptr(), msg.len() as _, output.as_mut_ptr())
};
ret_code.into()
}
}
substrate/frame/contracts/uapi/src/lib.rs
+139
View File
@@ -0,0 +1,139 @@
// Copyright (C) Parity Technologies (UK) Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! External C API to communicate with substrate contracts runtime module.
//!
//! Refer to substrate FRAME contract module for more documentation.
#![no_std]
mod flags;
pub use flags::*;
#[cfg(any(target_arch = "wasm32", target_arch = "riscv32"))]
mod host;
#[cfg(any(target_arch = "wasm32", target_arch = "riscv32"))]
pub use host::*;
macro_rules! define_error_codes {
(
$(
$( #[$attr:meta] )*
$name:ident = $discr:literal,
)*
) => {
/// Every error that can be returned to a contract when it calls any of the host functions.
#[derive(Debug)]
#[repr(u32)]
pub enum ReturnErrorCode {
/// API call successful.
Success = 0,
$(
$( #[$attr] )*
$name = $discr,
)*
/// Returns if an unknown error was received from the host module.
Unknown,
}
impl From<ReturnCode> for Result {
#[inline]
fn from(return_code: ReturnCode) -> Self {
match return_code.0 {
0 => Ok(()),
$(
$discr => Err(ReturnErrorCode::$name),
)*
_ => Err(ReturnErrorCode::Unknown),
}
}
}
};
}
impl From<ReturnErrorCode> for u32 {
fn from(code: ReturnErrorCode) -> u32 {
code as u32
}
}
define_error_codes! {
/// The called function trapped and has its state changes reverted.
/// In this case no output buffer is returned.
/// Can only be returned from `call` and `instantiate`.
CalleeTrapped = 1,
/// The called function ran to completion but decided to revert its state.
/// An output buffer is returned when one was supplied.
/// Can only be returned from `call` and `instantiate`.
CalleeReverted = 2,
/// The passed key does not exist in storage.
KeyNotFound = 3,
/// Deprecated and no longer returned: There is only the minimum balance.
_BelowSubsistenceThreshold = 4,
/// Transfer failed for other not further specified reason. Most probably
/// reserved or locked balance of the sender that was preventing the transfer.
TransferFailed = 5,
/// Deprecated and no longer returned: Endowment is no longer required.
_EndowmentTooLow = 6,
/// No code could be found at the supplied code hash.
CodeNotFound = 7,
/// The account that was called is no contract.
NotCallable = 8,
/// The call to `debug_message` had no effect because debug message
/// recording was disabled.
LoggingDisabled = 9,
/// The call dispatched by `call_runtime` was executed but returned an error.
CallRuntimeFailed = 10,
/// ECDSA public key recovery failed. Most probably wrong recovery id or signature.
EcdsaRecoveryFailed = 11,
/// sr25519 signature verification failed.
Sr25519VerifyFailed = 12,
/// The `xcm_execute` call failed.
XcmExecutionFailed = 13,
/// The `xcm_send` call failed.
XcmSendFailed = 14,
}
/// The raw return code returned by the host side.
#[repr(transparent)]
pub struct ReturnCode(u32);
/// Used as a sentinel value when reading and writing contract memory.
///
/// We use this value to signal `None` to a contract when only a primitive is
/// allowed and we don't want to go through encoding a full Rust type.
/// Using `u32::Max` is a safe sentinel because contracts are never
/// allowed to use such a large amount of resources. So this value doesn't
/// make sense for a memory location or length.
const SENTINEL: u32 = u32::MAX;
impl From<ReturnCode> for Option<u32> {
fn from(code: ReturnCode) -> Self {
(code.0 < SENTINEL).then_some(code.0)
}
}
impl ReturnCode {
/// Returns the raw underlying `u32` representation.
pub fn into_u32(self) -> u32 {
self.0
}
/// Returns the underlying `u32` converted into `bool`.
pub fn into_bool(self) -> bool {
self.0.ne(&0)
}
}
type Result = core::result::Result<(), ReturnErrorCode>;