use crate::{
exec::{ExecError, ExecResult, Ext, Key, TopicOf},
gas::{ChargedAmount, Token},
primitives::ExecReturnValue,
weights::WeightInfo,
BalanceOf, CodeHash, Config, DebugBufferVec, Error, SENTINEL,
};
use alloc::{boxed::Box, vec, vec::Vec};
use codec::{Decode, DecodeLimit, Encode, MaxEncodedLen};
use core::fmt;
use frame_support::{
dispatch::DispatchInfo, ensure, pallet_prelude::DispatchResultWithPostInfo, parameter_types,
traits::Get, weights::Weight,
};
use pallet_contracts_proc_macro::define_env;
use pallet_contracts_uapi::{CallFlags, ReturnFlags};
use sp_io::hashing::{blake2_128, blake2_256, keccak_256, sha2_256};
use sp_runtime::{
traits::{Bounded, Zero},
DispatchError, RuntimeDebug,
};
use wasmi::{core::HostError, errors::LinkerError, Linker, Memory, Store};
type CallOf<T> = <T as frame_system::Config>::RuntimeCall;
const MAX_DECODE_NESTING: u32 = 256;
pub enum AllowDeprecatedInterface {
No,
Yes,
}
pub enum AllowUnstableInterface {
No,
Yes,
}
pub trait Environment<HostState> {
fn define(
store: &mut Store<HostState>,
linker: &mut Linker<HostState>,
allow_unstable: AllowUnstableInterface,
allow_deprecated: AllowDeprecatedInterface,
) -> Result<(), LinkerError>;
}
enum KeyType {
Fix,
Var(u32),
}
pub use pallet_contracts_uapi::ReturnErrorCode;
parameter_types! {
const CallRuntimeFailed: ReturnErrorCode = ReturnErrorCode::CallRuntimeFailed;
const XcmExecutionFailed: ReturnErrorCode = ReturnErrorCode::XcmExecutionFailed;
}
impl From<ExecReturnValue> for ReturnErrorCode {
fn from(from: ExecReturnValue) -> Self {
if from.flags.contains(ReturnFlags::REVERT) {
Self::CalleeReverted
} else {
Self::Success
}
}
}
#[derive(RuntimeDebug)]
pub struct ReturnData {
flags: u32,
data: Vec<u8>,
}
#[derive(RuntimeDebug)]
pub enum TrapReason {
SupervisorError(DispatchError),
Return(ReturnData),
Termination,
}
impl<T: Into<DispatchError>> From<T> for TrapReason {
fn from(from: T) -> Self {
Self::SupervisorError(from.into())
}
}
impl fmt::Display for TrapReason {
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
Ok(())
}
}
impl HostError for TrapReason {}
#[cfg_attr(test, derive(Debug, PartialEq, Eq))]
#[derive(Copy, Clone)]
pub enum RuntimeCosts {
HostFn,
CopyFromContract(u32),
CopyToContract(u32),
Caller,
IsContract,
CodeHash,
OwnCodeHash,
CallerIsOrigin,
CallerIsRoot,
Address,
GasLeft,
Balance,
ValueTransferred,
MinimumBalance,
BlockNumber,
Now,
WeightToFee,
Terminate(u32),
Random,
DepositEvent { num_topic: u32, len: u32 },
DebugMessage(u32),
SetStorage { old_bytes: u32, new_bytes: u32 },
ClearStorage(u32),
ContainsStorage(u32),
GetStorage(u32),
TakeStorage(u32),
SetTransientStorage { old_bytes: u32, new_bytes: u32 },
ClearTransientStorage(u32),
ContainsTransientStorage(u32),
GetTransientStorage(u32),
TakeTransientStorage(u32),
Transfer,
CallBase,
DelegateCallBase,
CallTransferSurcharge,
CallInputCloned(u32),
Instantiate { input_data_len: u32, salt_len: u32 },
HashSha256(u32),
HashKeccak256(u32),
HashBlake256(u32),
HashBlake128(u32),
EcdsaRecovery,
Sr25519Verify(u32),
ChainExtension(Weight),
CallRuntime(Weight),
CallXcmExecute(Weight),
SetCodeHash,
EcdsaToEthAddress,
ReentranceCount,
AccountReentranceCount,
InstantiationNonce,
LockDelegateDependency,
UnlockDelegateDependency,
}
macro_rules! cost_storage {
(write_transient, $name:ident $(, $arg:expr )*) => {
T::WeightInfo::$name($( $arg ),*)
.saturating_add(T::WeightInfo::rollback_transient_storage())
.saturating_add(T::WeightInfo::set_transient_storage_full()
.saturating_sub(T::WeightInfo::set_transient_storage_empty()))
};
(read_transient, $name:ident $(, $arg:expr )*) => {
T::WeightInfo::$name($( $arg ),*)
.saturating_add(T::WeightInfo::get_transient_storage_full()
.saturating_sub(T::WeightInfo::get_transient_storage_empty()))
};
(write, $name:ident $(, $arg:expr )*) => {
T::WeightInfo::$name($( $arg ),*)
.saturating_add(T::WeightInfo::set_storage_full()
.saturating_sub(T::WeightInfo::set_storage_empty()))
};
(read, $name:ident $(, $arg:expr )*) => {
T::WeightInfo::$name($( $arg ),*)
.saturating_add(T::WeightInfo::get_storage_full()
.saturating_sub(T::WeightInfo::get_storage_empty()))
};
}
macro_rules! cost_args {
($name:ident, $( $arg: expr ),+) => {
(T::WeightInfo::$name($( $arg ),+).saturating_sub(cost_args!(@call_zero $name, $( $arg ),+)))
};
(@call_zero $name:ident, $( $arg:expr ),*) => {
T::WeightInfo::$name($( cost_args!(@replace_token $arg) ),*)
};
(@replace_token $_in:tt) => { 0 };
}
impl<T: Config> Token<T> for RuntimeCosts {
fn influence_lowest_gas_limit(&self) -> bool {
match self {
&Self::CallXcmExecute(_) => false,
_ => true,
}
}
fn weight(&self) -> Weight {
use self::RuntimeCosts::*;
match *self {
HostFn => cost_args!(noop_host_fn, 1),
CopyToContract(len) => T::WeightInfo::seal_input(len),
CopyFromContract(len) => T::WeightInfo::seal_return(len),
Caller => T::WeightInfo::seal_caller(),
IsContract => T::WeightInfo::seal_is_contract(),
CodeHash => T::WeightInfo::seal_code_hash(),
OwnCodeHash => T::WeightInfo::seal_own_code_hash(),
CallerIsOrigin => T::WeightInfo::seal_caller_is_origin(),
CallerIsRoot => T::WeightInfo::seal_caller_is_root(),
Address => T::WeightInfo::seal_address(),
GasLeft => T::WeightInfo::seal_gas_left(),
Balance => T::WeightInfo::seal_balance(),
ValueTransferred => T::WeightInfo::seal_value_transferred(),
MinimumBalance => T::WeightInfo::seal_minimum_balance(),
BlockNumber => T::WeightInfo::seal_block_number(),
Now => T::WeightInfo::seal_now(),
WeightToFee => T::WeightInfo::seal_weight_to_fee(),
Terminate(locked_dependencies) => T::WeightInfo::seal_terminate(locked_dependencies),
Random => T::WeightInfo::seal_random(),
DepositEvent { num_topic, len } => T::WeightInfo::seal_deposit_event(num_topic, len)
.saturating_add(Weight::from_parts(
T::Schedule::get().limits.event_ref_time.saturating_mul(len.into()),
0,
)),
DebugMessage(len) => T::WeightInfo::seal_debug_message(len),
SetStorage { new_bytes, old_bytes } =>
cost_storage!(write, seal_set_storage, new_bytes, old_bytes),
ClearStorage(len) => cost_storage!(write, seal_clear_storage, len),
ContainsStorage(len) => cost_storage!(read, seal_contains_storage, len),
GetStorage(len) => cost_storage!(read, seal_get_storage, len),
TakeStorage(len) => cost_storage!(write, seal_take_storage, len),
SetTransientStorage { new_bytes, old_bytes } =>
cost_storage!(write_transient, seal_set_transient_storage, new_bytes, old_bytes),
ClearTransientStorage(len) =>
cost_storage!(write_transient, seal_clear_transient_storage, len),
ContainsTransientStorage(len) =>
cost_storage!(read_transient, seal_contains_transient_storage, len),
GetTransientStorage(len) =>
cost_storage!(read_transient, seal_get_transient_storage, len),
TakeTransientStorage(len) =>
cost_storage!(write_transient, seal_take_transient_storage, len),
Transfer => T::WeightInfo::seal_transfer(),
CallBase => T::WeightInfo::seal_call(0, 0),
DelegateCallBase => T::WeightInfo::seal_delegate_call(),
CallTransferSurcharge => cost_args!(seal_call, 1, 0),
CallInputCloned(len) => cost_args!(seal_call, 0, len),
Instantiate { input_data_len, salt_len } =>
T::WeightInfo::seal_instantiate(input_data_len, salt_len),
HashSha256(len) => T::WeightInfo::seal_hash_sha2_256(len),
HashKeccak256(len) => T::WeightInfo::seal_hash_keccak_256(len),
HashBlake256(len) => T::WeightInfo::seal_hash_blake2_256(len),
HashBlake128(len) => T::WeightInfo::seal_hash_blake2_128(len),
EcdsaRecovery => T::WeightInfo::seal_ecdsa_recover(),
Sr25519Verify(len) => T::WeightInfo::seal_sr25519_verify(len),
ChainExtension(weight) | CallRuntime(weight) | CallXcmExecute(weight) => weight,
SetCodeHash => T::WeightInfo::seal_set_code_hash(),
EcdsaToEthAddress => T::WeightInfo::seal_ecdsa_to_eth_address(),
ReentranceCount => T::WeightInfo::seal_reentrance_count(),
AccountReentranceCount => T::WeightInfo::seal_account_reentrance_count(),
InstantiationNonce => T::WeightInfo::seal_instantiation_nonce(),
LockDelegateDependency => T::WeightInfo::lock_delegate_dependency(),
UnlockDelegateDependency => T::WeightInfo::unlock_delegate_dependency(),
}
}
}
macro_rules! charge_gas {
($runtime:expr, $costs:expr) => {{
$runtime.ext.gas_meter_mut().charge($costs)
}};
}
enum CallType {
Call { callee_ptr: u32, value_ptr: u32, deposit_ptr: u32, weight: Weight },
DelegateCall { code_hash_ptr: u32 },
}
impl CallType {
fn cost(&self) -> RuntimeCosts {
match self {
CallType::Call { .. } => RuntimeCosts::CallBase,
CallType::DelegateCall { .. } => RuntimeCosts::DelegateCallBase,
}
}
}
fn already_charged(_: u32) -> Option<RuntimeCosts> {
None
}
pub struct Runtime<'a, E: Ext + 'a> {
ext: &'a mut E,
input_data: Option<Vec<u8>>,
memory: Option<Memory>,
chain_extension: Option<Box<<E::T as Config>::ChainExtension>>,
}
impl<'a, E: Ext + 'a> Runtime<'a, E> {
pub fn new(ext: &'a mut E, input_data: Vec<u8>) -> Self {
Runtime {
ext,
input_data: Some(input_data),
memory: None,
chain_extension: Some(Box::new(Default::default())),
}
}
pub fn memory(&self) -> Option<Memory> {
self.memory
}
pub fn set_memory(&mut self, memory: Memory) {
self.memory = Some(memory);
}
pub fn to_execution_result(self, sandbox_result: Result<(), wasmi::Error>) -> ExecResult {
use wasmi::{
core::TrapCode,
errors::{ErrorKind, FuelError},
};
use TrapReason::*;
let Err(error) = sandbox_result else {
return Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() })
};
if let ErrorKind::Fuel(FuelError::OutOfFuel) = error.kind() {
return Err(Error::<E::T>::OutOfGas.into())
}
match error.as_trap_code() {
Some(TrapCode::OutOfFuel) => {
return Err(Error::<E::T>::OutOfGas.into())
},
Some(_trap_code) => {
return Err(Error::<E::T>::ContractTrapped.into())
},
None => {},
}
if let Some(reason) = &error.downcast_ref::<TrapReason>() {
match &reason {
Return(ReturnData { flags, data }) => {
let flags =
ReturnFlags::from_bits(*flags).ok_or(Error::<E::T>::InvalidCallFlags)?;
return Ok(ExecReturnValue { flags, data: data.to_vec() })
},
Termination =>
return Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }),
SupervisorError(error) => return Err((*error).into()),
}
}
log::debug!("Code rejected: {:?}", error);
Err(Error::<E::T>::CodeRejected.into())
}
pub fn ext(&mut self) -> &mut E {
self.ext
}
pub fn charge_gas(&mut self, costs: RuntimeCosts) -> Result<ChargedAmount, DispatchError> {
charge_gas!(self, costs)
}
pub fn adjust_gas(&mut self, charged: ChargedAmount, actual_costs: RuntimeCosts) {
self.ext.gas_meter_mut().adjust_gas(charged, actual_costs);
}
fn call_dispatchable<ErrorReturnCode: Get<ReturnErrorCode>>(
&mut self,
dispatch_info: DispatchInfo,
runtime_cost: impl Fn(Weight) -> RuntimeCosts,
run: impl FnOnce(&mut Self) -> DispatchResultWithPostInfo,
) -> Result<ReturnErrorCode, TrapReason> {
use frame_support::dispatch::extract_actual_weight;
let charged = self.charge_gas(runtime_cost(dispatch_info.weight))?;
let result = run(self);
let actual_weight = extract_actual_weight(&result, &dispatch_info);
self.adjust_gas(charged, runtime_cost(actual_weight));
match result {
Ok(_) => Ok(ReturnErrorCode::Success),
Err(e) => {
if self.ext.debug_buffer_enabled() {
self.ext.append_debug_buffer("call failed with: ");
self.ext.append_debug_buffer(e.into());
};
Ok(ErrorReturnCode::get())
},
}
}
pub fn read_sandbox_memory(
&self,
memory: &[u8],
ptr: u32,
len: u32,
) -> Result<Vec<u8>, DispatchError> {
ensure!(len <= self.ext.schedule().limits.max_memory_size(), Error::<E::T>::OutOfBounds);
let mut buf = vec![0u8; len as usize];
self.read_sandbox_memory_into_buf(memory, ptr, buf.as_mut_slice())?;
Ok(buf)
}
pub fn read_sandbox_memory_into_buf(
&self,
memory: &[u8],
ptr: u32,
buf: &mut [u8],
) -> Result<(), DispatchError> {
let ptr = ptr as usize;
let bound_checked =
memory.get(ptr..ptr + buf.len()).ok_or_else(|| Error::<E::T>::OutOfBounds)?;
buf.copy_from_slice(bound_checked);
Ok(())
}
pub fn read_sandbox_memory_as<D: Decode + MaxEncodedLen>(
&self,
memory: &[u8],
ptr: u32,
) -> Result<D, DispatchError> {
let ptr = ptr as usize;
let mut bound_checked = memory.get(ptr..).ok_or_else(|| Error::<E::T>::OutOfBounds)?;
let decoded = D::decode_with_depth_limit(MAX_DECODE_NESTING, &mut bound_checked)
.map_err(|_| DispatchError::from(Error::<E::T>::DecodingFailed))?;
Ok(decoded)
}
pub fn read_sandbox_memory_as_unbounded<D: Decode>(
&self,
memory: &[u8],
ptr: u32,
len: u32,
) -> Result<D, DispatchError> {
let ptr = ptr as usize;
let mut bound_checked =
memory.get(ptr..ptr + len as usize).ok_or_else(|| Error::<E::T>::OutOfBounds)?;
let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut bound_checked)
.map_err(|_| DispatchError::from(Error::<E::T>::DecodingFailed))?;
Ok(decoded)
}
pub fn write_sandbox_output(
&mut self,
memory: &mut [u8],
out_ptr: u32,
out_len_ptr: u32,
buf: &[u8],
allow_skip: bool,
create_token: impl FnOnce(u32) -> Option<RuntimeCosts>,
) -> Result<(), DispatchError> {
if allow_skip && out_ptr == SENTINEL {
return Ok(())
}
let buf_len = buf.len() as u32;
let len: u32 = self.read_sandbox_memory_as(memory, out_len_ptr)?;
if len < buf_len {
return Err(Error::<E::T>::OutputBufferTooSmall.into())
}
if let Some(costs) = create_token(buf_len) {
self.charge_gas(costs)?;
}
self.write_sandbox_memory(memory, out_ptr, buf)?;
self.write_sandbox_memory(memory, out_len_ptr, &buf_len.encode())
}
fn write_sandbox_memory(
&self,
memory: &mut [u8],
ptr: u32,
buf: &[u8],
) -> Result<(), DispatchError> {
let ptr = ptr as usize;
let bound_checked =
memory.get_mut(ptr..ptr + buf.len()).ok_or_else(|| Error::<E::T>::OutOfBounds)?;
bound_checked.copy_from_slice(buf);
Ok(())
}
fn compute_hash_on_intermediate_buffer<F, R>(
&self,
memory: &mut [u8],
hash_fn: F,
input_ptr: u32,
input_len: u32,
output_ptr: u32,
) -> Result<(), DispatchError>
where
F: FnOnce(&[u8]) -> R,
R: AsRef<[u8]>,
{
let input = self.read_sandbox_memory(memory, input_ptr, input_len)?;
let hash = hash_fn(&input);
self.write_sandbox_memory(memory, output_ptr, hash.as_ref())?;
Ok(())
}
fn err_into_return_code(from: DispatchError) -> Result<ReturnErrorCode, DispatchError> {
use ReturnErrorCode::*;
let transfer_failed = Error::<E::T>::TransferFailed.into();
let no_code = Error::<E::T>::CodeNotFound.into();
let not_found = Error::<E::T>::ContractNotFound.into();
match from {
x if x == transfer_failed => Ok(TransferFailed),
x if x == no_code => Ok(CodeNotFound),
x if x == not_found => Ok(NotCallable),
err => Err(err),
}
}
fn exec_into_return_code(from: ExecResult) -> Result<ReturnErrorCode, DispatchError> {
use crate::exec::ErrorOrigin::Callee;
let ExecError { error, origin } = match from {
Ok(retval) => return Ok(retval.into()),
Err(err) => err,
};
match (error, origin) {
(_, Callee) => Ok(ReturnErrorCode::CalleeTrapped),
(err, _) => Self::err_into_return_code(err),
}
}
fn decode_key(
&self,
memory: &[u8],
key_type: KeyType,
key_ptr: u32,
) -> Result<crate::exec::Key<E::T>, TrapReason> {
let res = match key_type {
KeyType::Fix => {
let key = self.read_sandbox_memory(memory, key_ptr, 32u32)?;
Key::try_from_fix(key)
},
KeyType::Var(len) => {
ensure!(
len <= <<E as Ext>::T as Config>::MaxStorageKeyLen::get(),
Error::<E::T>::DecodingFailed
);
let key = self.read_sandbox_memory(memory, key_ptr, len)?;
Key::try_from_var(key)
},
};
res.map_err(|_| Error::<E::T>::DecodingFailed.into())
}
fn set_storage(
&mut self,
memory: &[u8],
key_type: KeyType,
key_ptr: u32,
value_ptr: u32,
value_len: u32,
) -> Result<u32, TrapReason> {
let max_size = self.ext.max_value_size();
let charged = self
.charge_gas(RuntimeCosts::SetStorage { new_bytes: value_len, old_bytes: max_size })?;
if value_len > max_size {
return Err(Error::<E::T>::ValueTooLarge.into())
}
let key = self.decode_key(memory, key_type, key_ptr)?;
let value = Some(self.read_sandbox_memory(memory, value_ptr, value_len)?);
let write_outcome = self.ext.set_storage(&key, value, false)?;
self.adjust_gas(
charged,
RuntimeCosts::SetStorage { new_bytes: value_len, old_bytes: write_outcome.old_len() },
);
Ok(write_outcome.old_len_with_sentinel())
}
fn clear_storage(
&mut self,
memory: &[u8],
key_type: KeyType,
key_ptr: u32,
) -> Result<u32, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::ClearStorage(self.ext.max_value_size()))?;
let key = self.decode_key(memory, key_type, key_ptr)?;
let outcome = self.ext.set_storage(&key, None, false)?;
self.adjust_gas(charged, RuntimeCosts::ClearStorage(outcome.old_len()));
Ok(outcome.old_len_with_sentinel())
}
fn get_storage(
&mut self,
memory: &mut [u8],
key_type: KeyType,
key_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::GetStorage(self.ext.max_value_size()))?;
let key = self.decode_key(memory, key_type, key_ptr)?;
let outcome = self.ext.get_storage(&key);
if let Some(value) = outcome {
self.adjust_gas(charged, RuntimeCosts::GetStorage(value.len() as u32));
self.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&value,
false,
already_charged,
)?;
Ok(ReturnErrorCode::Success)
} else {
self.adjust_gas(charged, RuntimeCosts::GetStorage(0));
Ok(ReturnErrorCode::KeyNotFound)
}
}
fn contains_storage(
&mut self,
memory: &[u8],
key_type: KeyType,
key_ptr: u32,
) -> Result<u32, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::ContainsStorage(self.ext.max_value_size()))?;
let key = self.decode_key(memory, key_type, key_ptr)?;
let outcome = self.ext.get_storage_size(&key);
self.adjust_gas(charged, RuntimeCosts::ContainsStorage(outcome.unwrap_or(0)));
Ok(outcome.unwrap_or(SENTINEL))
}
fn set_transient_storage(
&mut self,
memory: &[u8],
key_type: KeyType,
key_ptr: u32,
value_ptr: u32,
value_len: u32,
) -> Result<u32, TrapReason> {
let max_size = self.ext.max_value_size();
let charged = self.charge_gas(RuntimeCosts::SetTransientStorage {
new_bytes: value_len,
old_bytes: max_size,
})?;
if value_len > max_size {
return Err(Error::<E::T>::ValueTooLarge.into())
}
let key = self.decode_key(memory, key_type, key_ptr)?;
let value = Some(self.read_sandbox_memory(memory, value_ptr, value_len)?);
let write_outcome = self.ext.set_transient_storage(&key, value, false)?;
self.adjust_gas(
charged,
RuntimeCosts::SetTransientStorage {
new_bytes: value_len,
old_bytes: write_outcome.old_len(),
},
);
Ok(write_outcome.old_len_with_sentinel())
}
fn clear_transient_storage(
&mut self,
memory: &[u8],
key_type: KeyType,
key_ptr: u32,
) -> Result<u32, TrapReason> {
let charged =
self.charge_gas(RuntimeCosts::ClearTransientStorage(self.ext.max_value_size()))?;
let key = self.decode_key(memory, key_type, key_ptr)?;
let outcome = self.ext.set_transient_storage(&key, None, false)?;
self.adjust_gas(charged, RuntimeCosts::ClearTransientStorage(outcome.old_len()));
Ok(outcome.old_len_with_sentinel())
}
fn get_transient_storage(
&mut self,
memory: &mut [u8],
key_type: KeyType,
key_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
let charged =
self.charge_gas(RuntimeCosts::GetTransientStorage(self.ext.max_value_size()))?;
let key = self.decode_key(memory, key_type, key_ptr)?;
let outcome = self.ext.get_transient_storage(&key);
if let Some(value) = outcome {
self.adjust_gas(charged, RuntimeCosts::GetTransientStorage(value.len() as u32));
self.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&value,
false,
already_charged,
)?;
Ok(ReturnErrorCode::Success)
} else {
self.adjust_gas(charged, RuntimeCosts::GetTransientStorage(0));
Ok(ReturnErrorCode::KeyNotFound)
}
}
fn contains_transient_storage(
&mut self,
memory: &[u8],
key_type: KeyType,
key_ptr: u32,
) -> Result<u32, TrapReason> {
let charged =
self.charge_gas(RuntimeCosts::ContainsTransientStorage(self.ext.max_value_size()))?;
let key = self.decode_key(memory, key_type, key_ptr)?;
let outcome = self.ext.get_transient_storage_size(&key);
self.adjust_gas(charged, RuntimeCosts::ContainsTransientStorage(outcome.unwrap_or(0)));
Ok(outcome.unwrap_or(SENTINEL))
}
fn take_transient_storage(
&mut self,
memory: &mut [u8],
key_type: KeyType,
key_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
let charged =
self.charge_gas(RuntimeCosts::TakeTransientStorage(self.ext.max_value_size()))?;
let key = self.decode_key(memory, key_type, key_ptr)?;
if let crate::storage::WriteOutcome::Taken(value) =
self.ext.set_transient_storage(&key, None, true)?
{
self.adjust_gas(charged, RuntimeCosts::TakeTransientStorage(value.len() as u32));
self.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&value,
false,
already_charged,
)?;
Ok(ReturnErrorCode::Success)
} else {
self.adjust_gas(charged, RuntimeCosts::TakeTransientStorage(0));
Ok(ReturnErrorCode::KeyNotFound)
}
}
fn call(
&mut self,
memory: &mut [u8],
flags: CallFlags,
call_type: CallType,
input_data_ptr: u32,
input_data_len: u32,
output_ptr: u32,
output_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
self.charge_gas(call_type.cost())?;
let input_data = if flags.contains(CallFlags::CLONE_INPUT) {
let input = self.input_data.as_ref().ok_or(Error::<E::T>::InputForwarded)?;
charge_gas!(self, RuntimeCosts::CallInputCloned(input.len() as u32))?;
input.clone()
} else if flags.contains(CallFlags::FORWARD_INPUT) {
self.input_data.take().ok_or(Error::<E::T>::InputForwarded)?
} else {
self.charge_gas(RuntimeCosts::CopyFromContract(input_data_len))?;
self.read_sandbox_memory(memory, input_data_ptr, input_data_len)?
};
let call_outcome = match call_type {
CallType::Call { callee_ptr, value_ptr, deposit_ptr, weight } => {
let callee: <<E as Ext>::T as frame_system::Config>::AccountId =
self.read_sandbox_memory_as(memory, callee_ptr)?;
let deposit_limit: BalanceOf<<E as Ext>::T> = if deposit_ptr == SENTINEL {
BalanceOf::<<E as Ext>::T>::zero()
} else {
self.read_sandbox_memory_as(memory, deposit_ptr)?
};
let read_only = flags.contains(CallFlags::READ_ONLY);
let value: BalanceOf<<E as Ext>::T> =
self.read_sandbox_memory_as(memory, value_ptr)?;
if value > 0u32.into() {
if read_only || self.ext.is_read_only() {
return Err(Error::<E::T>::StateChangeDenied.into());
}
self.charge_gas(RuntimeCosts::CallTransferSurcharge)?;
}
self.ext.call(
weight,
deposit_limit,
callee,
value,
input_data,
flags.contains(CallFlags::ALLOW_REENTRY),
read_only,
)
},
CallType::DelegateCall { code_hash_ptr } => {
if flags.intersects(CallFlags::ALLOW_REENTRY | CallFlags::READ_ONLY) {
return Err(Error::<E::T>::InvalidCallFlags.into())
}
let code_hash = self.read_sandbox_memory_as(memory, code_hash_ptr)?;
self.ext.delegate_call(code_hash, input_data)
},
};
if flags.contains(CallFlags::TAIL_CALL) {
if let Ok(return_value) = call_outcome {
return Err(TrapReason::Return(ReturnData {
flags: return_value.flags.bits(),
data: return_value.data,
}))
}
}
if let Ok(output) = &call_outcome {
self.write_sandbox_output(
memory,
output_ptr,
output_len_ptr,
&output.data,
true,
|len| Some(RuntimeCosts::CopyToContract(len)),
)?;
}
Ok(Runtime::<E>::exec_into_return_code(call_outcome)?)
}
fn instantiate(
&mut self,
memory: &mut [u8],
code_hash_ptr: u32,
weight: Weight,
deposit_ptr: u32,
value_ptr: u32,
input_data_ptr: u32,
input_data_len: u32,
address_ptr: u32,
address_len_ptr: u32,
output_ptr: u32,
output_len_ptr: u32,
salt_ptr: u32,
salt_len: u32,
) -> Result<ReturnErrorCode, TrapReason> {
self.charge_gas(RuntimeCosts::Instantiate { input_data_len, salt_len })?;
let deposit_limit: BalanceOf<<E as Ext>::T> = if deposit_ptr == SENTINEL {
BalanceOf::<<E as Ext>::T>::zero()
} else {
self.read_sandbox_memory_as(memory, deposit_ptr)?
};
let value: BalanceOf<<E as Ext>::T> = self.read_sandbox_memory_as(memory, value_ptr)?;
let code_hash: CodeHash<<E as Ext>::T> =
self.read_sandbox_memory_as(memory, code_hash_ptr)?;
let input_data = self.read_sandbox_memory(memory, input_data_ptr, input_data_len)?;
let salt = self.read_sandbox_memory(memory, salt_ptr, salt_len)?;
let instantiate_outcome =
self.ext.instantiate(weight, deposit_limit, code_hash, value, input_data, &salt);
if let Ok((address, output)) = &instantiate_outcome {
if !output.flags.contains(ReturnFlags::REVERT) {
self.write_sandbox_output(
memory,
address_ptr,
address_len_ptr,
&address.encode(),
true,
already_charged,
)?;
}
self.write_sandbox_output(
memory,
output_ptr,
output_len_ptr,
&output.data,
true,
|len| Some(RuntimeCosts::CopyToContract(len)),
)?;
}
Ok(Runtime::<E>::exec_into_return_code(instantiate_outcome.map(|(_, retval)| retval))?)
}
fn terminate(&mut self, memory: &[u8], beneficiary_ptr: u32) -> Result<(), TrapReason> {
let count = self.ext.locked_delegate_dependencies_count() as _;
self.charge_gas(RuntimeCosts::Terminate(count))?;
let beneficiary: <<E as Ext>::T as frame_system::Config>::AccountId =
self.read_sandbox_memory_as(memory, beneficiary_ptr)?;
self.ext.terminate(&beneficiary)?;
Err(TrapReason::Termination)
}
}
#[define_env(doc)]
pub mod env {
#[cfg(feature = "runtime-benchmarks")]
#[unstable]
fn noop(ctx: _, memory: _) -> Result<(), TrapReason> {
Ok(())
}
#[prefixed_alias]
#[mutating]
fn set_storage(
ctx: _,
memory: _,
key_ptr: u32,
value_ptr: u32,
value_len: u32,
) -> Result<(), TrapReason> {
ctx.set_storage(memory, KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
}
#[version(1)]
#[prefixed_alias]
#[mutating]
fn set_storage(
ctx: _,
memory: _,
key_ptr: u32,
value_ptr: u32,
value_len: u32,
) -> Result<u32, TrapReason> {
ctx.set_storage(memory, KeyType::Fix, key_ptr, value_ptr, value_len)
}
#[version(2)]
#[prefixed_alias]
#[mutating]
fn set_storage(
ctx: _,
memory: _,
key_ptr: u32,
key_len: u32,
value_ptr: u32,
value_len: u32,
) -> Result<u32, TrapReason> {
ctx.set_storage(memory, KeyType::Var(key_len), key_ptr, value_ptr, value_len)
}
#[prefixed_alias]
#[mutating]
fn clear_storage(ctx: _, memory: _, key_ptr: u32) -> Result<(), TrapReason> {
ctx.clear_storage(memory, KeyType::Fix, key_ptr).map(|_| ())
}
#[version(1)]
#[prefixed_alias]
#[mutating]
fn clear_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
ctx.clear_storage(memory, KeyType::Var(key_len), key_ptr)
}
#[prefixed_alias]
fn get_storage(
ctx: _,
memory: _,
key_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.get_storage(memory, KeyType::Fix, key_ptr, out_ptr, out_len_ptr)
}
#[version(1)]
#[prefixed_alias]
fn get_storage(
ctx: _,
memory: _,
key_ptr: u32,
key_len: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.get_storage(memory, KeyType::Var(key_len), key_ptr, out_ptr, out_len_ptr)
}
#[prefixed_alias]
fn contains_storage(ctx: _, memory: _, key_ptr: u32) -> Result<u32, TrapReason> {
ctx.contains_storage(memory, KeyType::Fix, key_ptr)
}
#[version(1)]
#[prefixed_alias]
fn contains_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
ctx.contains_storage(memory, KeyType::Var(key_len), key_ptr)
}
#[prefixed_alias]
#[mutating]
fn take_storage(
ctx: _,
memory: _,
key_ptr: u32,
key_len: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
let charged = ctx.charge_gas(RuntimeCosts::TakeStorage(ctx.ext.max_value_size()))?;
ensure!(
key_len <= <<E as Ext>::T as Config>::MaxStorageKeyLen::get(),
Error::<E::T>::DecodingFailed
);
let key = ctx.read_sandbox_memory(memory, key_ptr, key_len)?;
if let crate::storage::WriteOutcome::Taken(value) = ctx.ext.set_storage(
&Key::<E::T>::try_from_var(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
None,
true,
)? {
ctx.adjust_gas(charged, RuntimeCosts::TakeStorage(value.len() as u32));
ctx.write_sandbox_output(memory, out_ptr, out_len_ptr, &value, false, already_charged)?;
Ok(ReturnErrorCode::Success)
} else {
ctx.adjust_gas(charged, RuntimeCosts::TakeStorage(0));
Ok(ReturnErrorCode::KeyNotFound)
}
}
#[unstable]
fn set_transient_storage(
ctx: _,
memory: _,
key_ptr: u32,
key_len: u32,
value_ptr: u32,
value_len: u32,
) -> Result<u32, TrapReason> {
ctx.set_transient_storage(memory, KeyType::Var(key_len), key_ptr, value_ptr, value_len)
}
#[unstable]
fn clear_transient_storage(
ctx: _,
memory: _,
key_ptr: u32,
key_len: u32,
) -> Result<u32, TrapReason> {
ctx.clear_transient_storage(memory, KeyType::Var(key_len), key_ptr)
}
#[unstable]
fn get_transient_storage(
ctx: _,
memory: _,
key_ptr: u32,
key_len: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.get_transient_storage(memory, KeyType::Var(key_len), key_ptr, out_ptr, out_len_ptr)
}
#[unstable]
fn contains_transient_storage(
ctx: _,
memory: _,
key_ptr: u32,
key_len: u32,
) -> Result<u32, TrapReason> {
ctx.contains_transient_storage(memory, KeyType::Var(key_len), key_ptr)
}
#[unstable]
fn take_transient_storage(
ctx: _,
memory: _,
key_ptr: u32,
key_len: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.take_transient_storage(memory, KeyType::Var(key_len), key_ptr, out_ptr, out_len_ptr)
}
#[prefixed_alias]
#[mutating]
fn transfer(
ctx: _,
memory: _,
account_ptr: u32,
_account_len: u32,
value_ptr: u32,
_value_len: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::Transfer)?;
let callee: <<E as Ext>::T as frame_system::Config>::AccountId =
ctx.read_sandbox_memory_as(memory, account_ptr)?;
let value: BalanceOf<<E as Ext>::T> = ctx.read_sandbox_memory_as(memory, value_ptr)?;
let result = ctx.ext.transfer(&callee, value);
match result {
Ok(()) => Ok(ReturnErrorCode::Success),
Err(err) => {
let code = Runtime::<E>::err_into_return_code(err)?;
Ok(code)
},
}
}
#[prefixed_alias]
fn call(
ctx: _,
memory: _,
callee_ptr: u32,
_callee_len: u32,
gas: u64,
value_ptr: u32,
_value_len: u32,
input_data_ptr: u32,
input_data_len: u32,
output_ptr: u32,
output_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.call(
memory,
CallFlags::ALLOW_REENTRY,
CallType::Call {
callee_ptr,
value_ptr,
deposit_ptr: SENTINEL,
weight: Weight::from_parts(gas, 0),
},
input_data_ptr,
input_data_len,
output_ptr,
output_len_ptr,
)
}
#[version(1)]
#[prefixed_alias]
fn call(
ctx: _,
memory: _,
flags: u32,
callee_ptr: u32,
gas: u64,
value_ptr: u32,
input_data_ptr: u32,
input_data_len: u32,
output_ptr: u32,
output_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.call(
memory,
CallFlags::from_bits(flags).ok_or(Error::<E::T>::InvalidCallFlags)?,
CallType::Call {
callee_ptr,
value_ptr,
deposit_ptr: SENTINEL,
weight: Weight::from_parts(gas, 0),
},
input_data_ptr,
input_data_len,
output_ptr,
output_len_ptr,
)
}
#[version(2)]
fn call(
ctx: _,
memory: _,
flags: u32,
callee_ptr: u32,
ref_time_limit: u64,
proof_size_limit: u64,
deposit_ptr: u32,
value_ptr: u32,
input_data_ptr: u32,
input_data_len: u32,
output_ptr: u32,
output_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.call(
memory,
CallFlags::from_bits(flags).ok_or(Error::<E::T>::InvalidCallFlags)?,
CallType::Call {
callee_ptr,
value_ptr,
deposit_ptr,
weight: Weight::from_parts(ref_time_limit, proof_size_limit),
},
input_data_ptr,
input_data_len,
output_ptr,
output_len_ptr,
)
}
#[prefixed_alias]
fn delegate_call(
ctx: _,
memory: _,
flags: u32,
code_hash_ptr: u32,
input_data_ptr: u32,
input_data_len: u32,
output_ptr: u32,
output_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.call(
memory,
CallFlags::from_bits(flags).ok_or(Error::<E::T>::InvalidCallFlags)?,
CallType::DelegateCall { code_hash_ptr },
input_data_ptr,
input_data_len,
output_ptr,
output_len_ptr,
)
}
#[prefixed_alias]
#[mutating]
fn instantiate(
ctx: _,
memory: _,
code_hash_ptr: u32,
_code_hash_len: u32,
gas: u64,
value_ptr: u32,
_value_len: u32,
input_data_ptr: u32,
input_data_len: u32,
address_ptr: u32,
address_len_ptr: u32,
output_ptr: u32,
output_len_ptr: u32,
salt_ptr: u32,
salt_len: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.instantiate(
memory,
code_hash_ptr,
Weight::from_parts(gas, 0),
SENTINEL,
value_ptr,
input_data_ptr,
input_data_len,
address_ptr,
address_len_ptr,
output_ptr,
output_len_ptr,
salt_ptr,
salt_len,
)
}
#[version(1)]
#[prefixed_alias]
#[mutating]
fn instantiate(
ctx: _,
memory: _,
code_hash_ptr: u32,
gas: u64,
value_ptr: u32,
input_data_ptr: u32,
input_data_len: u32,
address_ptr: u32,
address_len_ptr: u32,
output_ptr: u32,
output_len_ptr: u32,
salt_ptr: u32,
salt_len: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.instantiate(
memory,
code_hash_ptr,
Weight::from_parts(gas, 0),
SENTINEL,
value_ptr,
input_data_ptr,
input_data_len,
address_ptr,
address_len_ptr,
output_ptr,
output_len_ptr,
salt_ptr,
salt_len,
)
}
#[version(2)]
#[mutating]
fn instantiate(
ctx: _,
memory: _,
code_hash_ptr: u32,
ref_time_limit: u64,
proof_size_limit: u64,
deposit_ptr: u32,
value_ptr: u32,
input_data_ptr: u32,
input_data_len: u32,
address_ptr: u32,
address_len_ptr: u32,
output_ptr: u32,
output_len_ptr: u32,
salt_ptr: u32,
salt_len: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.instantiate(
memory,
code_hash_ptr,
Weight::from_parts(ref_time_limit, proof_size_limit),
deposit_ptr,
value_ptr,
input_data_ptr,
input_data_len,
address_ptr,
address_len_ptr,
output_ptr,
output_len_ptr,
salt_ptr,
salt_len,
)
}
#[prefixed_alias]
#[mutating]
fn terminate(
ctx: _,
memory: _,
beneficiary_ptr: u32,
_beneficiary_len: u32,
) -> Result<(), TrapReason> {
ctx.terminate(memory, beneficiary_ptr)
}
#[version(1)]
#[prefixed_alias]
#[mutating]
fn terminate(ctx: _, memory: _, beneficiary_ptr: u32) -> Result<(), TrapReason> {
ctx.terminate(memory, beneficiary_ptr)
}
#[prefixed_alias]
fn input(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
if let Some(input) = ctx.input_data.take() {
ctx.write_sandbox_output(memory, out_ptr, out_len_ptr, &input, false, |len| {
Some(RuntimeCosts::CopyToContract(len))
})?;
ctx.input_data = Some(input);
Ok(())
} else {
Err(Error::<E::T>::InputForwarded.into())
}
}
fn seal_return(
ctx: _,
memory: _,
flags: u32,
data_ptr: u32,
data_len: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::CopyFromContract(data_len))?;
Err(TrapReason::Return(ReturnData {
flags,
data: ctx.read_sandbox_memory(memory, data_ptr, data_len)?,
}))
}
#[prefixed_alias]
fn caller(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Caller)?;
let caller = ctx.ext.caller().account_id()?.clone();
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&caller.encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
fn is_contract(ctx: _, memory: _, account_ptr: u32) -> Result<u32, TrapReason> {
ctx.charge_gas(RuntimeCosts::IsContract)?;
let address: <<E as Ext>::T as frame_system::Config>::AccountId =
ctx.read_sandbox_memory_as(memory, account_ptr)?;
Ok(ctx.ext.is_contract(&address) as u32)
}
#[prefixed_alias]
fn code_hash(
ctx: _,
memory: _,
account_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::CodeHash)?;
let address: <<E as Ext>::T as frame_system::Config>::AccountId =
ctx.read_sandbox_memory_as(memory, account_ptr)?;
if let Some(value) = ctx.ext.code_hash(&address) {
ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&value.encode(),
false,
already_charged,
)?;
Ok(ReturnErrorCode::Success)
} else {
Ok(ReturnErrorCode::KeyNotFound)
}
}
#[prefixed_alias]
fn own_code_hash(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::OwnCodeHash)?;
let code_hash_encoded = &ctx.ext.own_code_hash().encode();
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
code_hash_encoded,
false,
already_charged,
)?)
}
#[prefixed_alias]
fn caller_is_origin(ctx: _, _memory: _) -> Result<u32, TrapReason> {
ctx.charge_gas(RuntimeCosts::CallerIsOrigin)?;
Ok(ctx.ext.caller_is_origin() as u32)
}
fn caller_is_root(ctx: _, _memory: _) -> Result<u32, TrapReason> {
ctx.charge_gas(RuntimeCosts::CallerIsRoot)?;
Ok(ctx.ext.caller_is_root() as u32)
}
#[prefixed_alias]
fn address(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Address)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.address().encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
fn weight_to_fee(
ctx: _,
memory: _,
gas: u64,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<(), TrapReason> {
let gas = Weight::from_parts(gas, 0);
ctx.charge_gas(RuntimeCosts::WeightToFee)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.get_weight_price(gas).encode(),
false,
already_charged,
)?)
}
#[version(1)]
#[unstable]
fn weight_to_fee(
ctx: _,
memory: _,
ref_time_limit: u64,
proof_size_limit: u64,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<(), TrapReason> {
let weight = Weight::from_parts(ref_time_limit, proof_size_limit);
ctx.charge_gas(RuntimeCosts::WeightToFee)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.get_weight_price(weight).encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
fn gas_left(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::GasLeft)?;
let gas_left = &ctx.ext.gas_meter().gas_left().ref_time().encode();
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
gas_left,
false,
already_charged,
)?)
}
#[version(1)]
#[unstable]
fn gas_left(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::GasLeft)?;
let gas_left = &ctx.ext.gas_meter().gas_left().encode();
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
gas_left,
false,
already_charged,
)?)
}
#[prefixed_alias]
fn balance(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Balance)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.balance().encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
fn value_transferred(
ctx: _,
memory: _,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::ValueTransferred)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.value_transferred().encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
#[deprecated]
fn random(
ctx: _,
memory: _,
subject_ptr: u32,
subject_len: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Random)?;
if subject_len > ctx.ext.schedule().limits.subject_len {
return Err(Error::<E::T>::RandomSubjectTooLong.into())
}
let subject_buf = ctx.read_sandbox_memory(memory, subject_ptr, subject_len)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.random(&subject_buf).0.encode(),
false,
already_charged,
)?)
}
#[version(1)]
#[prefixed_alias]
#[deprecated]
fn random(
ctx: _,
memory: _,
subject_ptr: u32,
subject_len: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Random)?;
if subject_len > ctx.ext.schedule().limits.subject_len {
return Err(Error::<E::T>::RandomSubjectTooLong.into())
}
let subject_buf = ctx.read_sandbox_memory(memory, subject_ptr, subject_len)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.random(&subject_buf).encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
fn now(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Now)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.now().encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
fn minimum_balance(
ctx: _,
memory: _,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::MinimumBalance)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.minimum_balance().encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
#[deprecated]
fn tombstone_deposit(
ctx: _,
memory: _,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Balance)?;
let deposit = <BalanceOf<E::T>>::zero().encode();
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&deposit,
false,
already_charged,
)?)
}
#[prefixed_alias]
#[deprecated]
fn restore_to(
ctx: _,
memory: _,
_dest_ptr: u32,
_dest_len: u32,
_code_hash_ptr: u32,
_code_hash_len: u32,
_rent_allowance_ptr: u32,
_rent_allowance_len: u32,
_delta_ptr: u32,
_delta_count: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::DebugMessage(0))?;
Ok(())
}
#[version(1)]
#[prefixed_alias]
#[deprecated]
fn restore_to(
ctx: _,
memory: _,
_dest_ptr: u32,
_code_hash_ptr: u32,
_rent_allowance_ptr: u32,
_delta_ptr: u32,
_delta_count: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::DebugMessage(0))?;
Ok(())
}
#[prefixed_alias]
#[deprecated]
fn set_rent_allowance(
ctx: _,
memory: _,
_value_ptr: u32,
_value_len: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::DebugMessage(0))?;
Ok(())
}
#[version(1)]
#[prefixed_alias]
#[deprecated]
fn set_rent_allowance(ctx: _, _memory: _, _value_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::DebugMessage(0))?;
Ok(())
}
#[prefixed_alias]
#[deprecated]
fn rent_allowance(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Balance)?;
let rent_allowance = <BalanceOf<E::T>>::max_value().encode();
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&rent_allowance,
false,
already_charged,
)?)
}
#[prefixed_alias]
#[mutating]
fn deposit_event(
ctx: _,
memory: _,
topics_ptr: u32,
topics_len: u32,
data_ptr: u32,
data_len: u32,
) -> Result<(), TrapReason> {
let num_topic = topics_len
.checked_div(core::mem::size_of::<TopicOf<E::T>>() as u32)
.ok_or("Zero sized topics are not allowed")?;
ctx.charge_gas(RuntimeCosts::DepositEvent { num_topic, len: data_len })?;
if data_len > ctx.ext.max_value_size() {
return Err(Error::<E::T>::ValueTooLarge.into())
}
let topics: Vec<TopicOf<<E as Ext>::T>> = match topics_len {
0 => Vec::new(),
_ => ctx.read_sandbox_memory_as_unbounded(memory, topics_ptr, topics_len)?,
};
if topics.len() > ctx.ext.schedule().limits.event_topics as usize {
return Err(Error::<E::T>::TooManyTopics.into())
}
let event_data = ctx.read_sandbox_memory(memory, data_ptr, data_len)?;
ctx.ext.deposit_event(topics, event_data);
Ok(())
}
#[prefixed_alias]
fn block_number(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::BlockNumber)?;
Ok(ctx.write_sandbox_output(
memory,
out_ptr,
out_len_ptr,
&ctx.ext.block_number().encode(),
false,
already_charged,
)?)
}
#[prefixed_alias]
fn hash_sha2_256(
ctx: _,
memory: _,
input_ptr: u32,
input_len: u32,
output_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::HashSha256(input_len))?;
Ok(ctx.compute_hash_on_intermediate_buffer(
memory, sha2_256, input_ptr, input_len, output_ptr,
)?)
}
#[prefixed_alias]
fn hash_keccak_256(
ctx: _,
memory: _,
input_ptr: u32,
input_len: u32,
output_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::HashKeccak256(input_len))?;
Ok(ctx.compute_hash_on_intermediate_buffer(
memory, keccak_256, input_ptr, input_len, output_ptr,
)?)
}
#[prefixed_alias]
fn hash_blake2_256(
ctx: _,
memory: _,
input_ptr: u32,
input_len: u32,
output_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::HashBlake256(input_len))?;
Ok(ctx.compute_hash_on_intermediate_buffer(
memory, blake2_256, input_ptr, input_len, output_ptr,
)?)
}
#[prefixed_alias]
fn hash_blake2_128(
ctx: _,
memory: _,
input_ptr: u32,
input_len: u32,
output_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::HashBlake128(input_len))?;
Ok(ctx.compute_hash_on_intermediate_buffer(
memory, blake2_128, input_ptr, input_len, output_ptr,
)?)
}
#[prefixed_alias]
fn call_chain_extension(
ctx: _,
memory: _,
id: u32,
input_ptr: u32,
input_len: u32,
output_ptr: u32,
output_len_ptr: u32,
) -> Result<u32, TrapReason> {
use crate::chain_extension::{ChainExtension, Environment, RetVal};
if !<E::T as Config>::ChainExtension::enabled() {
return Err(Error::<E::T>::NoChainExtension.into())
}
let mut chain_extension = ctx.chain_extension.take().expect(
"Constructor initializes with `Some`. This is the only place where it is set to `None`.\
It is always reset to `Some` afterwards. qed"
);
let env =
Environment::new(ctx, memory, id, input_ptr, input_len, output_ptr, output_len_ptr);
let ret = match chain_extension.call(env)? {
RetVal::Converging(val) => Ok(val),
RetVal::Diverging { flags, data } =>
Err(TrapReason::Return(ReturnData { flags: flags.bits(), data })),
};
ctx.chain_extension = Some(chain_extension);
ret
}
#[prefixed_alias]
fn debug_message(
ctx: _,
memory: _,
str_ptr: u32,
str_len: u32,
) -> Result<ReturnErrorCode, TrapReason> {
let str_len = str_len.min(DebugBufferVec::<E::T>::bound() as u32);
ctx.charge_gas(RuntimeCosts::DebugMessage(str_len))?;
if ctx.ext.append_debug_buffer("") {
let data = ctx.read_sandbox_memory(memory, str_ptr, str_len)?;
if let Some(msg) = core::str::from_utf8(&data).ok() {
ctx.ext.append_debug_buffer(msg);
}
}
Ok(ReturnErrorCode::Success)
}
#[mutating]
fn call_runtime(
ctx: _,
memory: _,
call_ptr: u32,
call_len: u32,
) -> Result<ReturnErrorCode, TrapReason> {
use frame_support::dispatch::GetDispatchInfo;
ctx.charge_gas(RuntimeCosts::CopyFromContract(call_len))?;
let call: <E::T as Config>::RuntimeCall =
ctx.read_sandbox_memory_as_unbounded(memory, call_ptr, call_len)?;
ctx.call_dispatchable::<CallRuntimeFailed>(
call.get_dispatch_info(),
RuntimeCosts::CallRuntime,
|ctx| ctx.ext.call_runtime(call),
)
}
#[mutating]
fn xcm_execute(
ctx: _,
memory: _,
msg_ptr: u32,
msg_len: u32,
) -> Result<ReturnErrorCode, TrapReason> {
use frame_support::dispatch::DispatchInfo;
use xcm::VersionedXcm;
use xcm_builder::{ExecuteController, ExecuteControllerWeightInfo};
ctx.charge_gas(RuntimeCosts::CopyFromContract(msg_len))?;
let message: VersionedXcm<CallOf<E::T>> =
ctx.read_sandbox_memory_as_unbounded(memory, msg_ptr, msg_len)?;
let execute_weight =
<<E::T as Config>::Xcm as ExecuteController<_, _>>::WeightInfo::execute();
let weight = ctx.ext.gas_meter().gas_left().max(execute_weight);
let dispatch_info = DispatchInfo { weight, ..Default::default() };
ctx.call_dispatchable::<XcmExecutionFailed>(
dispatch_info,
RuntimeCosts::CallXcmExecute,
|ctx| {
let origin = crate::RawOrigin::Signed(ctx.ext.address().clone()).into();
let weight_used = <<E::T as Config>::Xcm>::execute(
origin,
Box::new(message),
weight.saturating_sub(execute_weight),
)?;
Ok(Some(weight_used.saturating_add(execute_weight)).into())
},
)
}
#[mutating]
fn xcm_send(
ctx: _,
memory: _,
dest_ptr: u32,
msg_ptr: u32,
msg_len: u32,
output_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
use xcm::{VersionedLocation, VersionedXcm};
use xcm_builder::{SendController, SendControllerWeightInfo};
ctx.charge_gas(RuntimeCosts::CopyFromContract(msg_len))?;
let dest: VersionedLocation = ctx.read_sandbox_memory_as(memory, dest_ptr)?;
let message: VersionedXcm<()> =
ctx.read_sandbox_memory_as_unbounded(memory, msg_ptr, msg_len)?;
let weight = <<E::T as Config>::Xcm as SendController<_>>::WeightInfo::send();
ctx.charge_gas(RuntimeCosts::CallRuntime(weight))?;
let origin = crate::RawOrigin::Signed(ctx.ext.address().clone()).into();
match <<E::T as Config>::Xcm>::send(origin, dest.into(), message.into()) {
Ok(message_id) => {
ctx.write_sandbox_memory(memory, output_ptr, &message_id.encode())?;
Ok(ReturnErrorCode::Success)
},
Err(e) => {
if ctx.ext.append_debug_buffer("") {
ctx.ext.append_debug_buffer("seal0::xcm_send failed with: ");
ctx.ext.append_debug_buffer(e.into());
};
Ok(ReturnErrorCode::XcmSendFailed)
},
}
}
#[prefixed_alias]
fn ecdsa_recover(
ctx: _,
memory: _,
signature_ptr: u32,
message_hash_ptr: u32,
output_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::EcdsaRecovery)?;
let mut signature: [u8; 65] = [0; 65];
ctx.read_sandbox_memory_into_buf(memory, signature_ptr, &mut signature)?;
let mut message_hash: [u8; 32] = [0; 32];
ctx.read_sandbox_memory_into_buf(memory, message_hash_ptr, &mut message_hash)?;
let result = ctx.ext.ecdsa_recover(&signature, &message_hash);
match result {
Ok(pub_key) => {
ctx.write_sandbox_memory(memory, output_ptr, pub_key.as_ref())?;
Ok(ReturnErrorCode::Success)
},
Err(_) => Ok(ReturnErrorCode::EcdsaRecoveryFailed),
}
}
fn sr25519_verify(
ctx: _,
memory: _,
signature_ptr: u32,
pub_key_ptr: u32,
message_len: u32,
message_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::Sr25519Verify(message_len))?;
let mut signature: [u8; 64] = [0; 64];
ctx.read_sandbox_memory_into_buf(memory, signature_ptr, &mut signature)?;
let mut pub_key: [u8; 32] = [0; 32];
ctx.read_sandbox_memory_into_buf(memory, pub_key_ptr, &mut pub_key)?;
let message: Vec<u8> = ctx.read_sandbox_memory(memory, message_ptr, message_len)?;
if ctx.ext.sr25519_verify(&signature, &message, &pub_key) {
Ok(ReturnErrorCode::Success)
} else {
Ok(ReturnErrorCode::Sr25519VerifyFailed)
}
}
#[prefixed_alias]
#[mutating]
fn set_code_hash(ctx: _, memory: _, code_hash_ptr: u32) -> Result<ReturnErrorCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::SetCodeHash)?;
let code_hash: CodeHash<<E as Ext>::T> =
ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
match ctx.ext.set_code_hash(code_hash) {
Err(err) => {
let code = Runtime::<E>::err_into_return_code(err)?;
Ok(code)
},
Ok(()) => Ok(ReturnErrorCode::Success),
}
}
#[prefixed_alias]
fn ecdsa_to_eth_address(
ctx: _,
memory: _,
key_ptr: u32,
out_ptr: u32,
) -> Result<ReturnErrorCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::EcdsaToEthAddress)?;
let mut compressed_key: [u8; 33] = [0; 33];
ctx.read_sandbox_memory_into_buf(memory, key_ptr, &mut compressed_key)?;
let result = ctx.ext.ecdsa_to_eth_address(&compressed_key);
match result {
Ok(eth_address) => {
ctx.write_sandbox_memory(memory, out_ptr, eth_address.as_ref())?;
Ok(ReturnErrorCode::Success)
},
Err(_) => Ok(ReturnErrorCode::EcdsaRecoveryFailed),
}
}
#[unstable]
fn reentrance_count(ctx: _, memory: _) -> Result<u32, TrapReason> {
ctx.charge_gas(RuntimeCosts::ReentranceCount)?;
Ok(ctx.ext.reentrance_count())
}
#[unstable]
fn account_reentrance_count(ctx: _, memory: _, account_ptr: u32) -> Result<u32, TrapReason> {
ctx.charge_gas(RuntimeCosts::AccountReentranceCount)?;
let account_id: <<E as Ext>::T as frame_system::Config>::AccountId =
ctx.read_sandbox_memory_as(memory, account_ptr)?;
Ok(ctx.ext.account_reentrance_count(&account_id))
}
fn instantiation_nonce(ctx: _, _memory: _) -> Result<u64, TrapReason> {
ctx.charge_gas(RuntimeCosts::InstantiationNonce)?;
Ok(ctx.ext.nonce())
}
#[mutating]
fn lock_delegate_dependency(ctx: _, memory: _, code_hash_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::LockDelegateDependency)?;
let code_hash = ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
ctx.ext.lock_delegate_dependency(code_hash)?;
Ok(())
}
#[mutating]
fn unlock_delegate_dependency(ctx: _, memory: _, code_hash_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::UnlockDelegateDependency)?;
let code_hash = ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
ctx.ext.unlock_delegate_dependency(&code_hash)?;
Ok(())
}
}