Lines
0 %
Functions
Branches
100 %
// 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.
//! Provides implementations for the runtime interface traits.
#[cfg(feature = "std")]
use crate::host::*;
#[cfg(not(feature = "std"))]
use crate::wasm::*;
use crate::{
pass_by::{Codec, Enum, Inner, PassBy, PassByInner},
util::{pack_ptr_and_len, unpack_ptr_and_len},
Pointer, RIType,
};
#[cfg(all(not(feature = "std"), not(feature = "disable_target_static_assertions")))]
use static_assertions::assert_eq_size;
use sp_wasm_interface::{FunctionContext, Result};
use codec::{Decode, Encode};
use core::{any::TypeId, mem};
use alloc::vec::Vec;
use alloc::borrow::Cow;
// Make sure that our assumptions for storing a pointer + its size in `u64` is valid.
assert_eq_size!(usize, u32);
assert_eq_size!(*const u8, u32);
/// Implement the traits for the given primitive traits.
macro_rules! impl_traits_for_primitives {
(
$(
$rty:ty, $fty:ty,
)*
) => {
/// The type is passed directly.
impl RIType for $rty {
type FFIType = $fty;
}
impl IntoFFIValue for $rty {
type Owned = ();
fn into_ffi_value(&self) -> WrappedFFIValue<$fty> {
(*self as $fty).into()
impl FromFFIValue for $rty {
fn from_ffi_value(arg: $fty) -> $rty {
arg as $rty
type SelfInstance = $rty;
fn from_ffi_value(_: &mut dyn FunctionContext, arg: $fty) -> Result<$rty> {
Ok(arg as $rty)
fn into_ffi_value(self, _: &mut dyn FunctionContext) -> Result<$fty> {
Ok(self as $fty)
impl_traits_for_primitives! {
u8, u32,
u16, u32,
u32, u32,
u64, u64,
i8, i32,
i16, i32,
i32, i32,
i64, i64,
/// `bool` is passed as `u32`.
///
/// - `1`: true
/// - `0`: false
impl RIType for bool {
type FFIType = u32;
impl IntoFFIValue for bool {
fn into_ffi_value(&self) -> WrappedFFIValue<u32> {
if *self { 1 } else { 0 }.into()
impl FromFFIValue for bool {
fn from_ffi_value(arg: u32) -> bool {
arg == 1
type SelfInstance = bool;
fn from_ffi_value(_: &mut dyn FunctionContext, arg: u32) -> Result<bool> {
Ok(arg == 1)
fn into_ffi_value(self, _: &mut dyn FunctionContext) -> Result<u32> {
Ok(if self { 1 } else { 0 })
/// The type is passed as `u64`.
/// The `u64` value is build by `length 32bit << 32 | pointer 32bit`
/// If `T == u8` the length and the pointer are taken directly from `Self`.
/// Otherwise `Self` is encoded and the length and the pointer are taken from the encoded vector.
impl<T> RIType for Vec<T> {
type FFIType = u64;
impl<T: 'static + Encode> IntoFFIValue for Vec<T> {
fn into_ffi_value(self, context: &mut dyn FunctionContext) -> Result<u64> {
let vec: Cow<'_, [u8]> = if TypeId::of::<T>() == TypeId::of::<u8>() {
unsafe { Cow::Borrowed(mem::transmute(&self[..])) }
} else {
Cow::Owned(self.encode())
let ptr = context.allocate_memory(vec.as_ref().len() as u32)?;
context.write_memory(ptr, &vec)?;
Ok(pack_ptr_and_len(ptr.into(), vec.len() as u32))
impl<T: 'static + Decode> FromFFIValue for Vec<T> {
type SelfInstance = Vec<T>;
fn from_ffi_value(context: &mut dyn FunctionContext, arg: u64) -> Result<Vec<T>> {
<[T] as FromFFIValue>::from_ffi_value(context, arg)
type Owned = Vec<u8>;
fn into_ffi_value(&self) -> WrappedFFIValue<u64, Vec<u8>> {
self[..].into_ffi_value()
fn from_ffi_value(arg: u64) -> Vec<T> {
let (ptr, len) = unpack_ptr_and_len(arg);
let len = len as usize;
if len == 0 {
return Vec::new()
let data = unsafe { Vec::from_raw_parts(ptr as *mut u8, len, len) };
if TypeId::of::<T>() == TypeId::of::<u8>() {
unsafe { mem::transmute(data) }
Self::decode(&mut &data[..]).expect("Host to wasm values are encoded correctly; qed")
impl<T> RIType for [T] {
impl<T: 'static + Decode> FromFFIValue for [T] {
let vec = context.read_memory(Pointer::new(ptr), len)?;
Ok(unsafe { mem::transmute(vec) })
Ok(Vec::<T>::decode(&mut &vec[..])
.expect("Wasm to host values are encoded correctly; qed"))
impl IntoPreallocatedFFIValue for [u8] {
type SelfInstance = Vec<u8>;
fn into_preallocated_ffi_value(
self_instance: Self::SelfInstance,
context: &mut dyn FunctionContext,
allocated: u64,
) -> Result<()> {
let (ptr, len) = unpack_ptr_and_len(allocated);
if (len as usize) < self_instance.len() {
Err(format!(
"Preallocated buffer is not big enough (given {} vs needed {})!",
len,
self_instance.len()
))
context.write_memory(Pointer::new(ptr), &self_instance)
impl<T: 'static + Encode> IntoFFIValue for [T] {
let slice = unsafe { mem::transmute::<&[T], &[u8]>(self) };
pack_ptr_and_len(slice.as_ptr() as u32, slice.len() as u32).into()
let data = self.encode();
let ffi_value = pack_ptr_and_len(data.as_ptr() as u32, data.len() as u32);
(ffi_value, data).into()
/// The type is passed as `u32`.
/// The `u32` is the pointer to the array.
impl<const N: usize> RIType for [u8; N] {
impl<const N: usize> IntoFFIValue for [u8; N] {
(self.as_ptr() as u32).into()
impl<const N: usize> FromFFIValue for [u8; N] {
fn from_ffi_value(arg: u32) -> [u8; N] {
let mut res = [0u8; N];
let data = unsafe { Vec::from_raw_parts(arg as *mut u8, N, N) };
res.copy_from_slice(&data);
res
type SelfInstance = [u8; N];
fn from_ffi_value(context: &mut dyn FunctionContext, arg: u32) -> Result<[u8; N]> {
context.read_memory_into(Pointer::new(arg), &mut res)?;
Ok(res)
fn into_ffi_value(self, context: &mut dyn FunctionContext) -> Result<u32> {
let addr = context.allocate_memory(N as u32)?;
context.write_memory(addr, &self)?;
Ok(addr.into())
impl<const N: usize> IntoPreallocatedFFIValue for [u8; N] {
allocated: u32,
context.write_memory(Pointer::new(allocated), &self_instance)
impl<T: codec::Codec, E: codec::Codec> PassBy for core::result::Result<T, E> {
type PassBy = Codec<Self>;
impl<T: codec::Codec> PassBy for Option<T> {
#[impl_trait_for_tuples::impl_for_tuples(30)]
#[tuple_types_no_default_trait_bound]
impl PassBy for Tuple
where
Self: codec::Codec,
{
/// Implement `PassBy` with `Inner` for the given fixed sized hash types.
macro_rules! for_primitive_types {
{ $( $hash:ident $n:expr ),* $(,)? } => {
impl PassBy for primitive_types::$hash {
type PassBy = Inner<Self, [u8; $n]>;
impl PassByInner for primitive_types::$hash {
type Inner = [u8; $n];
fn inner(&self) -> &Self::Inner {
&self.0
fn into_inner(self) -> Self::Inner {
self.0
fn from_inner(inner: Self::Inner) -> Self {
Self(inner)
for_primitive_types! {
H160 20,
H256 32,
H512 64,
/// The length and the pointer are taken directly from `Self`.
impl RIType for str {
impl FromFFIValue for str {
type SelfInstance = String;
fn from_ffi_value(context: &mut dyn FunctionContext, arg: u64) -> Result<String> {
// The data is valid utf8, as it is stored as `&str` in wasm.
String::from_utf8(vec).map_err(|_| "Invalid utf8 data provided".into())
impl IntoFFIValue for str {
fn into_ffi_value(&self) -> WrappedFFIValue<u64, ()> {
let bytes = self.as_bytes();
pack_ptr_and_len(bytes.as_ptr() as u32, bytes.len() as u32).into()
impl<T: sp_wasm_interface::PointerType> RIType for Pointer<T> {
impl<T> RIType for Pointer<T> {
impl<T> IntoFFIValue for Pointer<T> {
(*self as u32).into()
impl<T> FromFFIValue for Pointer<T> {
fn from_ffi_value(arg: u32) -> Self {
arg as _
impl<T: sp_wasm_interface::PointerType> FromFFIValue for Pointer<T> {
type SelfInstance = Self;
fn from_ffi_value(_: &mut dyn FunctionContext, arg: u32) -> Result<Self> {
Ok(Pointer::new(arg))
impl<T: sp_wasm_interface::PointerType> IntoFFIValue for Pointer<T> {
Ok(self.into())
/// Implement the traits for `u128`/`i128`
macro_rules! for_u128_i128 {
($type:ty) => {
/// `u128`/`i128` is passed as `u32`.
/// The `u32` is a pointer to an `[u8; 16]` array.
impl RIType for $type {
impl IntoFFIValue for $type {
unsafe { (mem::transmute::<&Self, *const u8>(self) as u32).into() }
impl FromFFIValue for $type {
fn from_ffi_value(arg: u32) -> $type {
<$type>::from_le_bytes(<[u8; mem::size_of::<$type>()]>::from_ffi_value(arg))
type SelfInstance = $type;
fn from_ffi_value(context: &mut dyn FunctionContext, arg: u32) -> Result<$type> {
let mut res = [0u8; mem::size_of::<$type>()];
Ok(<$type>::from_le_bytes(res))
let addr = context.allocate_memory(mem::size_of::<$type>() as u32)?;
context.write_memory(addr, &self.to_le_bytes())?;
for_u128_i128!(u128);
for_u128_i128!(i128);
impl PassBy for sp_wasm_interface::ValueType {
type PassBy = Enum<sp_wasm_interface::ValueType>;
impl PassBy for sp_wasm_interface::Value {
type PassBy = Codec<sp_wasm_interface::Value>;
impl PassBy for sp_storage::TrackedStorageKey {
impl PassBy for sp_storage::StateVersion {
type PassBy = Enum<Self>;
impl PassBy for sp_externalities::MultiRemovalResults {