pallet_revive.rs

// Copyright (C) Use Ink (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.

#[cfg(feature = "xcm")]
use ink_primitives::Weight;
use ink_primitives::{
    Address,
    CodeHashErr,
    H256,
    U256,
    abi::{
        AbiEncodeWith,
        Ink,
        Sol,
    },
    sol::SolResultEncode,
};
use ink_storage_traits::{
    Storable,
    decode_all,
};
use pallet_revive_uapi::{
    CallFlags,
    HostFn,
    HostFnImpl as ext,
    ReturnErrorCode,
    ReturnFlags,
    StorageFlags,
};
#[cfg(feature = "xcm")]
use xcm::VersionedXcm;

use crate::{
    DecodeDispatch,
    DispatchError,
    EnvBackend,
    Environment,
    Result,
    TypedEnvBackend,
    call::{
        Call,
        CallParams,
        ConstructorReturnType,
        CreateParams,
        DelegateCall,
        FromAddr,
        LimitParamsV2,
        utils::{
            DecodeMessageResult,
            EncodeArgsWith,
        },
    },
    engine::on_chain::{
        EncodeScope,
        EnvInstance,
        ScopedBuffer,
    },
    event::{
        Event,
        TopicEncoder,
        TopicsBuilderBackend,
    },
    hash::{
        Blake2x128,
        Blake2x256,
        CryptoHash,
        HashOutput,
        Keccak256,
        Sha2x256,
    },
    types::FromLittleEndian,
};

/// The code hash of an existing account without code.
/// This is the `keccak256` hash of empty data.
/// ```no_compile
/// const EMPTY_CODE_HASH: H256 =
///     H256(sp_core::hex2array!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"));
/// ````
const EMPTY_CODE_HASH: H256 = H256([
    197, 210, 70, 1, 134, 247, 35, 60, 146, 126, 125, 178, 220, 199, 3, 192, 229, 0, 182,
    83, 202, 130, 39, 59, 123, 250, 216, 4, 93, 133, 164, 112,
]);

const H256_ZERO: H256 = H256::zero();

impl CryptoHash for Blake2x128 {
    fn hash(input: &[u8], output: &mut <Self as HashOutput>::Type) {
        type OutputType = [u8; 16];
        static_assertions::assert_type_eq_all!(
            <Blake2x128 as HashOutput>::Type,
            OutputType
        );
        let output: &mut OutputType = array_mut_ref!(output, 0, 16);

        let mut buffer = [0u8; 32];
        let mut output_buffer = [0u8; 32];

        let sel = const { solidity_selector("hashBlake128(bytes)") };
        buffer[..4].copy_from_slice(&sel[..4]);

        // we pass `offset = 32`, as the `bytes` payload starts there (right after the
        // offset word), we pass `offset_pos = 0`, as the callee takes only one argument.
        let n = solidity_encode_bytes(input, 32, 0, &mut buffer[4..]);

        const ADDR: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000900");
        let call_result = ext::delegate_call(
            CallFlags::empty(),
            &ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &buffer[..4 + n],
            Some(&mut &mut output_buffer[..]),
        );
        call_result.expect("call host function failed");
        output[..].copy_from_slice(&output_buffer[16..]);
    }

    fn hash_with_buffer(
        _input: &[u8],
        _buffer: &mut [u8],
        _output: &mut <Self as HashOutput>::Type,
    ) {
        panic!(
            "Hashing Blake2x128 can be done without a buffer, by calling a host function"
        );
    }
}

/// Returns the Solidity selector for `fn_sig`.
///
/// Note that this is a const function, it is evaluated at compile time.
///
/// # Usage
///
/// ```
/// let sel = solidity_selector("ownCodeHash()");
/// assert_eq!(sel, [219, 107, 220, 138]);
/// ```
pub const fn solidity_selector(fn_sig: &str) -> [u8; 4] {
    let output: [u8; 32] = const_crypto::sha3::Keccak256::new()
        .update(fn_sig.as_bytes())
        .finalize();
    [output[0], output[1], output[2], output[3]]
}

/// Encodes a `u32` to big-endian `[u8; 32]` with padded zeros.
fn encode_u32(value: u32, out: &mut [u8]) {
    debug_assert_eq!(out.len(), 32);
    out[28..].copy_from_slice(&value.to_be_bytes()); // last 4 bytes
}

/// Encodes a `bool` to big-endian `[u8; 32]` with padded zeros.
fn encode_bool(value: bool, out: &mut [u8]) {
    debug_assert_eq!(out.len(), 32);
    if value {
        out[31] = 1;
    }
}

const STORAGE_PRECOMPILE_ADDR: [u8; 20] =
    hex_literal::hex!("0000000000000000000000000000000000000901");

#[cfg(feature = "xcm")]
const XCM_PRECOMPILE_ADDR: [u8; 20] =
    hex_literal::hex!("00000000000000000000000000000000000A0000");

/// Four bytes are required to encode a Solidity selector;
const SOL_ENCODED_SELECTOR_LEN: usize = 4;

/// Number of bytes required to encode the `uint32 flags` parameter
/// that the `Storage` pre-compile functions take.
const SOL_ENCODED_FLAGS_LEN: usize = 32;

/// Number of bytes required to encode the `bool isFixedKey` parameter
/// that the `Storage` pre-compile functions take.
const SOL_ENCODED_IS_FIXED_KEY_LEN: usize = 32;

/// Number of bytes required to store the offset word when encoding
/// to the Solidity type `bytes`.
const SOL_BYTES_OFFSET_WORD_LEN: usize = 32;

/// When encoding a Rust `[u8]` to Solidity `bytes`, a small amount
/// of overhead space is required (for the 32 bytes offset + 32 bytes
/// length word).
const SOL_BYTES_ENCODING_OVERHEAD: usize = 64;

/// Encodes the `bytes` argument for the Solidity ABI.
/// The result is written to `out`.
///
/// Returns the number of bytes written.
///
/// # Arguments
///
/// - `input`: the bytes to encode.
/// - `offset`: the position in `out` where the data segment of `input` starts. The data
///   segment is composed of [length word (32 bytes)] [input (padded to 32)]`.
/// - `offset_pos`: the position in `out` where to write the `offset` word to.
/// - `out`: the output buffer.
///
/// # Developer Note
///
/// The returned layout will be
///
///     `... [offset (32 bytes)] ... [len (32 bytes)] [data (padded to 32)] ...`
///
/// The `out` byte array needs to be able to hold
/// (in the worst case) 95 bytes more than `input.len()`.
///
/// This is because we write the following to `out`:
///   * The offset word → always 32 bytes.
///   * The length word → always 32 bytes.
///   * The input itself → exactly `input.len()` bytes.
///   * We pad the input to a multiple of 32 → between 0 and 31 extra bytes.
fn solidity_encode_bytes(
    input: &[u8],
    offset: u32,
    offset_pos: usize,
    out: &mut [u8],
) -> usize {
    let input_len = input.len();
    let padded_len = solidity_padded_len(input_len);

    // out_len = 32 + padded_len
    //         = 32 + ceil(input_len / 32) * 32
    assert!(out.len() >= padded_len + SOL_BYTES_ENCODING_OVERHEAD);

    // Encode offset as a 32-byte big-endian word
    out[offset_pos + 28..offset_pos + 32].copy_from_slice(&offset.to_be_bytes()[..4]);
    out[offset_pos..offset_pos + 28].copy_from_slice(&[0u8; 28]); // make sure the first bytes are zeroed

    // Encode length as a 32-byte big-endian word
    let mut len_word = [0u8; 32];
    // We are at most on a 64-bit architecture, hence we can safely assume `len < 2^64`.
    let len_bytes = (input_len as u64).to_be_bytes();
    len_word[24..32].copy_from_slice(&len_bytes);

    // we take `offset: u32` as a parameter of `solidity_encode_bytes`,
    // as we need to extract the big endian bytes above.
    let offset = offset as usize;

    // The offset is a 32 byte word
    out[offset..offset + 32].copy_from_slice(&len_word);

    // Number of bytes required to encode the length of the `bytes` array
    // (i.e. the "length word").
    const BYTES_LEN_WORD: usize = 32;

    // Write the `input` at `offset_pos`, after the 32 byte `len` word
    out[offset + BYTES_LEN_WORD..offset + BYTES_LEN_WORD + input_len]
        .copy_from_slice(input);

    64 + padded_len
}

/// Returns the Solidity word padded length for the given input length (i.e. next multiple
/// of 32 for the given number).
///
/// # Developer Note
// The implementation does not use `.div_ceil()`, as that function is more complex
// and would use up more stack space.
#[allow(clippy::manual_div_ceil)]
#[inline(always)]
const fn solidity_padded_len(len: usize) -> usize {
    ((len + 31) / 32) * 32
}

impl CryptoHash for Blake2x256 {
    fn hash(_input: &[u8], _output: &mut <Self as HashOutput>::Type) {
        panic!("Hashing Blake2x256 requires calling a pre-compile and a buffer");
    }

    fn hash_with_buffer(
        input: &[u8],
        buffer: &mut [u8],
        output: &mut <Self as HashOutput>::Type,
    ) {
        type OutputType = [u8; 32];
        static_assertions::assert_type_eq_all!(
            <Blake2x256 as HashOutput>::Type,
            OutputType
        );
        let output: &mut OutputType = array_mut_ref!(output, 0, 32);

        let sel = const { solidity_selector("hashBlake256(bytes)") };
        buffer[..4].copy_from_slice(&sel[..4]);

        // we pass `offset = 32`, as the `bytes` payload starts there (right after the
        // offset word)
        let n = solidity_encode_bytes(input, 32, 0, &mut buffer[4..]);

        const ADDR: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000900");
        let call_result = ext::delegate_call(
            CallFlags::empty(),
            &ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &buffer[..4 + n],
            Some(&mut &mut output[..]),
        );
        call_result.expect("call host function failed");
    }
}

impl CryptoHash for Sha2x256 {
    fn hash(input: &[u8], output: &mut <Self as HashOutput>::Type) {
        type OutputType = [u8; 32];
        static_assertions::assert_type_eq_all!(
            <Sha2x256 as HashOutput>::Type,
            OutputType
        );
        let output: &mut OutputType = array_mut_ref!(output, 0, 32);

        const ADDR: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000002");
        // todo return value?
        let _ = ext::call(
            CallFlags::empty(),
            &ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            input,
            Some(&mut &mut output[..]),
        );
    }

    fn hash_with_buffer(
        _input: &[u8],
        _buffer: &mut [u8],
        _output: &mut <Self as HashOutput>::Type,
    ) {
        panic!(
            "Hashing Sha2x256 can be done without a buffer, by calling a host function"
        );
    }
}

impl CryptoHash for Keccak256 {
    fn hash(input: &[u8], output: &mut <Self as HashOutput>::Type) {
        type OutputType = [u8; 32];
        static_assertions::assert_type_eq_all!(
            <Keccak256 as HashOutput>::Type,
            OutputType
        );
        let output: &mut OutputType = array_mut_ref!(output, 0, 32);
        ext::hash_keccak_256(input, output);
    }

    fn hash_with_buffer(
        _input: &[u8],
        _buffer: &mut [u8],
        _output: &mut <Self as HashOutput>::Type,
    ) {
        panic!(
            "Hashing Keccak256 can be done without a buffer, by calling a host function"
        );
    }
}

pub struct TopicsBuilder<'a> {
    scoped_buffer: ScopedBuffer<'a>,
}

impl<'a> From<ScopedBuffer<'a>> for TopicsBuilder<'a> {
    fn from(scoped_buffer: ScopedBuffer<'a>) -> Self {
        Self { scoped_buffer }
    }
}

impl<'a, Abi> TopicsBuilderBackend<Abi> for TopicsBuilder<'a>
where
    Abi: TopicEncoder,
{
    type Output = (ScopedBuffer<'a>, &'a mut [u8]);

    fn push_topic<T>(&mut self, topic_value: &T)
    where
        T: AbiEncodeWith<Abi>,
    {
        let output = if <Abi as TopicEncoder>::REQUIRES_BUFFER {
            let mut output = [0u8; 32];
            let split = self.scoped_buffer.split();
            let buffer = split.take_rest();
            <Abi as TopicEncoder>::encode_topic_with_hash_buffer(
                topic_value,
                &mut output,
                buffer,
            );
            output
        } else {
            <Abi as TopicEncoder>::encode_topic(topic_value)
        };
        self.scoped_buffer.append_bytes(output.as_slice());
    }

    fn output(mut self) -> Self::Output {
        let encoded_topics = self.scoped_buffer.take_appended();
        (self.scoped_buffer, encoded_topics)
    }
}

impl TopicEncoder for Ink {
    const REQUIRES_BUFFER: bool = true;

    fn encode_topic<T>(_value: &T) -> [u8; 32]
    where
        T: AbiEncodeWith<Self>,
    {
        panic!("Blake2x256 hashing requires calling a pre-compile and a buffer");
    }

    fn encode_topic_with_hash_buffer<T>(
        value: &T,
        output: &mut [u8; 32],
        buffer: &mut [u8],
    ) where
        T: AbiEncodeWith<Self>,
    {
        let mut scoped_buffer = ScopedBuffer::from(buffer);

        let encoded = scoped_buffer.take_encoded_with(|buff| value.encode_to_slice(buff));
        let len_encoded = encoded.len();
        let solidity_encoding_buffer = scoped_buffer.take(
            SOL_ENCODED_SELECTOR_LEN
                + SOL_BYTES_ENCODING_OVERHEAD
                + solidity_padded_len(len_encoded),
        );

        if len_encoded <= 32 {
            output[..len_encoded].copy_from_slice(encoded);
        } else {
            <Blake2x256 as CryptoHash>::hash_with_buffer(
                encoded,
                &mut solidity_encoding_buffer[..],
                output,
            );
        }
    }
}

impl TopicEncoder for Sol {
    const REQUIRES_BUFFER: bool = false;

    fn encode_topic<T>(value: &T) -> [u8; 32]
    where
        T: AbiEncodeWith<Self>,
    {
        value.encode_topic(<Keccak256 as CryptoHash>::hash)
    }

    fn encode_topic_with_hash_buffer<T>(
        _value: &T,
        _output: &mut [u8; 32],
        _buffer: &mut [u8],
    ) where
        T: AbiEncodeWith<Self>,
    {
        panic!(
            "Keccak-256 hashing can be done without a buffer, by calling a host function"
        );
    }
}

impl EnvInstance {
    #[inline(always)]
    /// Returns a new scoped buffer for the entire scope of the static 16 kB buffer.
    fn scoped_buffer(&mut self) -> ScopedBuffer<'_> {
        ScopedBuffer::from(&mut self.buffer[..])
    }

    /// Returns the contract property value from its little-endian representation.
    ///
    /// # Note
    ///
    /// This skips the potentially costly decoding step that is often equivalent to a
    /// `memcpy`.
    #[inline(always)]
    fn get_property_little_endian<T>(&mut self, ext_fn: fn(output: &mut [u8; 32])) -> T
    where
        T: FromLittleEndian,
    {
        let mut scope = self.scoped_buffer();
        let u256: &mut [u8; 32] = scope
            .take(32)
            .try_into()
            .expect("failed to take 32 bytes from buffer");
        ext_fn(u256);
        let mut result = <T as FromLittleEndian>::Bytes::default();
        let len = result.as_ref().len();
        result.as_mut()[..].copy_from_slice(&u256[..len]);
        <T as FromLittleEndian>::from_le_bytes(result)
    }
}

fn call_bool_precompile(selector: [u8; 4], output: &mut [u8]) -> bool {
    debug_assert_eq!(output.len(), 32);
    const ADDR: [u8; 20] = hex_literal::hex!("0000000000000000000000000000000000000900");
    ext::call(
        CallFlags::empty(),
        &ADDR,
        u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
        u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
        &[u8::MAX; 32], // No deposit limit.
        &U256::zero().to_little_endian(), // Value transferred to the contract.
        &selector[..],
        Some(&mut &mut output[..]),
    )
    .expect("call host function failed");
    if output[31] == 1 {
        debug_assert_eq!(&output[..31], [0u8; 31]);
        return true;
    }
    debug_assert_eq!(&output[..32], [0u8; 32]);
    false
}

/// Calls a function on the `pallet-revive` `Storage` pre-compile "contract".
///
/// # Developer Note
///
/// This function assumes that the called pre-compiles all have this function
/// signature for the arguments:
///
/// ```no_compile
/// function containsStorage(uint32 flags, bool isFixedKey, bytes memory key)
/// ```
///
/// The function makes heavy use of operating on byte slices and the positions
/// in the slice are calculated based on the size of these three arguments.
///
/// The return type does not matter.
fn call_storage_precompile(
    input_buf: &mut &mut [u8],
    selector: [u8; 4],
    key: &[u8],
    output: &mut [u8],
) -> core::result::Result<(), ReturnErrorCode> {
    input_buf.fill(0);

    debug_assert_eq!(
        SOL_ENCODED_SELECTOR_LEN
            + SOL_ENCODED_FLAGS_LEN
            + SOL_ENCODED_IS_FIXED_KEY_LEN
            + SOL_BYTES_ENCODING_OVERHEAD
            + solidity_padded_len(key.len()),
        input_buf.len(),
        "input buffer has an unexpected size",
    );

    input_buf[..4].copy_from_slice(&selector[..]);
    encode_u32(STORAGE_FLAGS.bits(), &mut input_buf[4..36]); // todo @cmichi optimize
    encode_bool(false, &mut input_buf[36..68]); // todo @cmichi optimize

    let encoded_bytes_len = solidity_encode_bytes(
        key,
        // The offset is 96 here because all `Storage` pre-compile functions
        // take the input arguments `(uint32 flags, bool isFixedKey, bytes memory key)`.
        //
        // The offset is where the data payload of the third argument, `bytes`, starts:
        // 32 bytes for `flags` + 32 bytes for `isFixedKey` + 32 bytes for the `offset`
        // word that comes first when encoding `bytes`.
        // 96 then points to the `len|data` segment of `bytes`
        (SOL_ENCODED_FLAGS_LEN + SOL_ENCODED_IS_FIXED_KEY_LEN + SOL_BYTES_OFFSET_WORD_LEN)
            as u32,
        // encode the `bytes` starting at the appropriate position in the slice
        64,
        &mut input_buf[SOL_ENCODED_SELECTOR_LEN..],
    );

    // todo @cmichi check if we might better return `None` in this situation. perhaps a
    // zero sized key is legal?
    debug_assert!(
        encoded_bytes_len >= SOL_BYTES_ENCODING_OVERHEAD + 32,
        "the `bytes` encoding length was < 96, meaning we didn't encode a 32 byte `key`. \
        calling this function without `key` does not make sense and is unexpected."
    );

    // `output` needs to hold at least 32 bytes, for the len field of `bytes`.
    // if no `bytes` are returned from the delegate call we will at the minimum
    // have the `len` field.
    assert!(output.len() >= 32);

    ext::delegate_call(
        CallFlags::empty(),
        &STORAGE_PRECOMPILE_ADDR,
        u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
        u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
        &[u8::MAX; 32], // No deposit limit.
        &input_buf[..SOL_ENCODED_SELECTOR_LEN
            + SOL_ENCODED_FLAGS_LEN
            + SOL_ENCODED_IS_FIXED_KEY_LEN
            + encoded_bytes_len],
        Some(&mut &mut output[..]),
    )
}

/// Simple decoder for a Solidity `bytes` type.
///
/// # Important
///
/// This function assumes that it is decoding a single
/// bytes return type!
///
/// - Fine: `function foo() returns (bytes memory);`
/// - Not Fine: `function foo() returns (bool, bytes memory);`
///
/// # Return Value
///
/// Returns the number of bytes written to `out`.
fn decode_bytes(input: &[u8], out: &mut [u8]) -> usize {
    let mut buf = [0u8; 4];
    buf[..].copy_from_slice(&input[28..32]);
    debug_assert_eq!(
        {
            // offset
            u32::from_be_bytes(buf) as usize
        },
        64
    );

    let mut buf = [0u8; 4];
    buf[..].copy_from_slice(&input[60..64]);
    let bytes_len = u32::from_be_bytes(buf) as usize;

    // we start decoding at the start of the payload.
    // the payload starts at the `len` word here:
    // `bytes = offset (32 bytes) | len (32 bytes) | data`
    out[..bytes_len].copy_from_slice(&input[64..64 + bytes_len]);
    bytes_len
}

const STORAGE_FLAGS: StorageFlags = StorageFlags::empty();
const TRANSIENT_STORAGE_FLAGS: StorageFlags = StorageFlags::TRANSIENT;

impl EnvBackend for EnvInstance {
    fn set_contract_storage<K, V>(&mut self, key: &K, value: &V) -> Option<u32>
    where
        K: scale::Encode,
        V: Storable,
    {
        let mut buffer = self.scoped_buffer();
        let key = buffer.take_encoded(key);
        let value = buffer.take_storable_encoded(value);
        ext::set_storage(STORAGE_FLAGS, key, value)
    }

    fn get_contract_storage<K, R>(&mut self, key: &K) -> Result<Option<R>>
    where
        K: scale::Encode,
        R: Storable,
    {
        let mut buffer = self.scoped_buffer();
        let key = buffer.take_encoded(key);
        let output = &mut buffer.take_rest();
        match ext::get_storage(STORAGE_FLAGS, key, output) {
            Ok(_) => (),
            Err(ReturnErrorCode::KeyNotFound) => return Ok(None),
            Err(_) => panic!("encountered unexpected error"),
        }
        let decoded = decode_all(&mut &output[..])?;
        Ok(Some(decoded))
    }

    fn remaining_buffer(&mut self) -> usize {
        self.scoped_buffer().remaining_buffer()
    }

    /// Calls the following function on the `pallet-revive` `Storage` pre-compile:
    ///
    /// ```no_compile
    /// function takeStorage(uint32 flags, bool isFixedKey, bytes memory key)
    ///     external returns (bytes memory)
    /// ```
    fn take_contract_storage<K, R>(&mut self, key: &K) -> Result<Option<R>>
    where
        K: scale::Encode,
        R: Storable,
    {
        let mut buffer = self.scoped_buffer();
        let key = buffer.take_encoded(key);

        let padded_len = solidity_padded_len(key.len());
        let buf: &mut [u8] = buffer.take(
            SOL_ENCODED_SELECTOR_LEN
                + SOL_ENCODED_FLAGS_LEN
                + SOL_ENCODED_IS_FIXED_KEY_LEN
                + SOL_BYTES_ENCODING_OVERHEAD
                + padded_len,
        );

        let output = &mut buffer.take_rest();

        let sel = const { solidity_selector("takeStorage(uint32,bool,bytes)") };
        call_storage_precompile(&mut &mut buf[..], sel, key, output)
            .expect("failed calling Storage pre-compile (take)");

        debug_assert!(
            !output.is_empty(),
            "output must always contain at least the len and offset of `bytes`"
        );

        // extract the `len` from the returned Solidity `bytes`
        let mut buf = [0u8; 4];
        buf[..].copy_from_slice(&output[60..64]);
        let bytes_len = u32::from_be_bytes(buf) as usize;

        if bytes_len == 0 {
            return Ok(None);
        }

        if output.len() < SOL_BYTES_ENCODING_OVERHEAD + bytes_len {
            return Err(crate::Error::BufferTooSmall);
        }

        // We start decoding at the start of the payload.
        // The payload starts at the `len` word here:
        // `bytes = offset (32 bytes) | len (32 bytes) | data`
        let decoded = decode_all(
            &mut &output
                [SOL_BYTES_ENCODING_OVERHEAD..bytes_len + SOL_BYTES_ENCODING_OVERHEAD],
        )?;

        Ok(Some(decoded))
    }

    /// Calls the following function on the `pallet-revive` `Storage` pre-compile:
    ///
    /// ```no_compile
    /// function containsStorage(uint32 flags, bool isFixedKey, bytes memory key)
    ///     external returns (bool containedKey, uint valueLen)
    /// ```
    fn contains_contract_storage<K>(&mut self, key: &K) -> Option<u32>
    where
        K: scale::Encode,
    {
        let mut buffer = self.scoped_buffer();
        let key = buffer.take_encoded(key);

        let padded_len = solidity_padded_len(key.len());
        let buf: &mut [u8] = buffer.take(
            SOL_ENCODED_SELECTOR_LEN
                + SOL_ENCODED_FLAGS_LEN
                + SOL_ENCODED_IS_FIXED_KEY_LEN
                + SOL_BYTES_ENCODING_OVERHEAD
                + padded_len,
        );
        let output = buffer.take(64);
        let sel = const { solidity_selector("containsStorage(uint32,bool,bytes)") };
        call_storage_precompile(&mut &mut buf[..], sel, key, &mut output[..])
            .expect("failed calling Storage pre-compile (contains)");

        // Check the returned `containedKey` boolean value
        if output[31] == 0 {
            debug_assert!(
                output.iter().all(|x| *x == 0),
                "both `containedKey` and `valueLen` need to be zero"
            );
            return None;
        }

        let mut value_len_buf = [0u8; 4];
        value_len_buf[..4].copy_from_slice(&output[60..64]);
        Some(u32::from_be_bytes(value_len_buf))
    }

    /// Calls the following function on the `pallet-revive` `Storage` pre-compile:
    ///
    /// ```no_compile
    /// function clearStorage(uint32 flags, bool isFixedKey, bytes memory key)
    ///     external returns (bool containedKey, uint valueLen);
    /// ```
    fn clear_contract_storage<K>(&mut self, key: &K) -> Option<u32>
    where
        K: scale::Encode,
    {
        let mut buffer = self.scoped_buffer();
        let key = buffer.take_encoded(key);

        let padded_len = solidity_padded_len(key.len());
        let buf: &mut [u8] = buffer.take(
            SOL_ENCODED_SELECTOR_LEN
                + SOL_ENCODED_FLAGS_LEN
                + SOL_ENCODED_IS_FIXED_KEY_LEN
                + SOL_BYTES_ENCODING_OVERHEAD
                + padded_len,
        );
        let output = buffer.take(64);

        let sel = const { solidity_selector("clearStorage(uint32,bool,bytes)") };
        call_storage_precompile(&mut &mut buf[..], sel, key, &mut output[..])
            .expect("failed calling Storage pre-compile (clear)");

        // Check the returned `containedKey` boolean value
        if output[31] == 0 {
            debug_assert!(
                output.iter().all(|x| *x == 0),
                "both `containedKey` and `valueLen` need to be zero"
            );
            return None;
        }

        let mut value_len_buf = [0u8; 4];
        value_len_buf[..4].copy_from_slice(&output[60..64]);
        Some(u32::from_be_bytes(value_len_buf))
    }

    fn decode_input<T>(&mut self) -> core::result::Result<T, DispatchError>
    where
        T: DecodeDispatch,
    {
        let full_scope = &mut self.scoped_buffer().take_rest();
        ext::call_data_copy(full_scope, 0);
        DecodeDispatch::decode_dispatch(&mut &full_scope[..])
    }

    fn return_value<R>(&mut self, flags: ReturnFlags, return_value: &R) -> !
    where
        R: scale::Encode,
    {
        let mut scope = EncodeScope::from(&mut self.buffer[..]);
        return_value.encode_to(&mut scope);
        let len = scope.len();
        if len == 0 {
            ext::return_value(flags, &[]);
        } else {
            ext::return_value(flags, &self.buffer[..][..len]);
        }
    }

    fn return_value_solidity<R>(&mut self, flags: ReturnFlags, return_value: &R) -> !
    where
        R: for<'a> SolResultEncode<'a>,
    {
        let encoded = return_value.encode();
        ext::return_value(flags, &encoded[..]);
    }

    fn hash_bytes<H>(&mut self, input: &[u8], output: &mut <H as HashOutput>::Type)
    where
        H: CryptoHash,
    {
        <H as CryptoHash>::hash(input, output)
    }

    fn hash_encoded<H, T>(&mut self, input: &T, output: &mut <H as HashOutput>::Type)
    where
        H: CryptoHash,
        T: scale::Encode,
    {
        let mut scope = self.scoped_buffer();
        let enc_input = scope.take_encoded(input);
        <H as CryptoHash>::hash(enc_input, output)
    }

    fn bn128_add(&mut self, x1: U256, y1: U256, x2: U256, y2: U256) -> (U256, U256) {
        const BN128_ADD: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000006");

        let mut input = [0u8; 128];
        input[..32].copy_from_slice(&x1.to_big_endian());
        input[32..64].copy_from_slice(&y1.to_big_endian());
        input[64..96].copy_from_slice(&x2.to_big_endian());
        input[96..128].copy_from_slice(&y2.to_big_endian());

        let mut output = [0u8; 64];
        let _ = ext::call(
            CallFlags::empty(),
            &BN128_ADD,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &input[..],
            Some(&mut &mut output[..]),
        );
        let x3 = U256::from_big_endian(&output[..32]);
        let y3 = U256::from_big_endian(&output[32..64]);
        (x3, y3)
    }

    fn bn128_mul(&mut self, x1: U256, y1: U256, scalar: U256) -> (U256, U256) {
        const BN128_ADD: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000007");

        let mut input = [0u8; 128];
        input[..32].copy_from_slice(&x1.to_big_endian());
        input[32..64].copy_from_slice(&y1.to_big_endian());
        input[64..96].copy_from_slice(&scalar.to_big_endian());

        let mut output = [0u8; 64];
        let _ = ext::call(
            CallFlags::empty(),
            &BN128_ADD,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &input[..],
            Some(&mut &mut output[..]),
        );
        let x2 = U256::from_big_endian(&output[..32]);
        let y2 = U256::from_big_endian(&output[32..64]);
        (x2, y2)
    }

    fn bn128_pairing(&mut self, input: &[u8]) -> bool {
        const BN128_ADD: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000008");

        let mut output = [0u8; 32];
        let _ = ext::call(
            CallFlags::empty(),
            &BN128_ADD,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &input[..],
            Some(&mut &mut output[..]),
        );
        if output[31] == 1 {
            debug_assert_eq!(&output[..31], [0u8; 31]);
            return true;
        }
        debug_assert_eq!(&output[..32], [0u8; 32]);
        false
    }

    fn ecdsa_recover(
        &mut self,
        signature: &[u8; 65],
        message_hash: &[u8; 32],
        output: &mut [u8; 33],
    ) -> Result<()> {
        // todo change fn args to just take the slice callee_input slice directly
        let mut callee_input = [0u8; 65 + 32];
        callee_input[..65].copy_from_slice(&signature[..65]);
        callee_input[65..65 + 32].copy_from_slice(&message_hash[..32]);

        const ECRECOVER: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000001");
        // todo return value?
        let _ = ext::call(
            CallFlags::empty(),
            &ECRECOVER,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &callee_input[..],
            Some(&mut &mut output[..]),
        );
        Ok(())
    }

    #[cfg(feature = "unstable-hostfn")]
    fn ecdsa_to_eth_address(
        &mut self,
        pubkey: &[u8; 33],
        output: &mut [u8; 20],
    ) -> Result<()> {
        ext::ecdsa_to_eth_address(pubkey, output).map_err(Into::into)
    }

    #[cfg(feature = "unstable-hostfn")]
    fn sr25519_verify(
        &mut self,
        signature: &[u8; 64],
        message: &[u8],
        pub_key: &[u8; 32],
    ) -> Result<()> {
        ext::sr25519_verify(signature, message, pub_key).map_err(Into::into)
    }

    #[cfg(feature = "unstable-hostfn")]
    fn set_code_hash(&mut self, code_hash: &H256) -> Result<()> {
        ext::set_code_hash(code_hash.as_fixed_bytes());
        Ok(()) // todo
    }
}

// TODO remove anything with hash
impl TypedEnvBackend for EnvInstance {
    fn caller(&mut self) -> Address {
        let mut scope = self.scoped_buffer();

        let h160: &mut [u8; 20] = scope.take(20).try_into().unwrap();
        ext::caller(h160);
        // TODO: check decode, I think this could just be from_le_bytes
        scale::Decode::decode(&mut &h160[..])
            .expect("The executed contract must have a caller with a valid account id.")
    }

    fn gas_limit(&mut self) -> u64 {
        ext::gas_limit()
    }

    fn gas_price(&mut self) -> u64 {
        ext::gas_price()
    }

    fn gas_left(&mut self) -> u64 {
        ext::ref_time_left()
    }

    fn call_data_size(&mut self) -> u64 {
        ext::call_data_size()
    }

    fn return_data_size(&mut self) -> u64 {
        ext::return_data_size()
    }

    fn chain_id(&mut self) -> U256 {
        let mut scope = self.scoped_buffer();
        let u256: &mut [u8; 32] = scope.take(32).try_into().unwrap();

        ext::chain_id(u256);
        U256::from_le_bytes(*u256)
    }

    fn balance_of(&mut self, addr: Address) -> U256 {
        let mut scope = self.scoped_buffer();
        let u256: &mut [u8; 32] = scope.take(32).try_into().unwrap();

        let addr = addr.as_fixed_bytes();

        ext::balance_of(&addr, u256);
        U256::from_le_bytes(*u256)
    }

    fn base_fee(&mut self) -> U256 {
        let mut scope = self.scoped_buffer();
        let u256: &mut [u8; 32] = scope.take(32).try_into().unwrap();

        ext::base_fee(u256);
        U256::from_le_bytes(*u256)
    }

    fn origin(&mut self) -> Address {
        let mut scope = self.scoped_buffer();
        let h160: &mut [u8; 20] = scope.take(20).try_into().unwrap();

        ext::origin(h160);
        h160.into()
    }

    fn code_size(&mut self, addr: Address) -> u64 {
        let addr = addr.as_fixed_bytes();

        ext::code_size(addr)
    }

    fn block_hash<E: Environment>(&mut self, block_number: E::BlockNumber) -> H256 {
        let mut scope = self.scoped_buffer();
        let output: &mut [u8; 32] = scope.take(32).try_into().unwrap();

        let block_number = {
            let mut bytes = [0u8; 32];
            let encoded = scope.take_encoded(&block_number);
            // NOTE: panics if encoding is bigger than 32 bytes.
            bytes[..encoded.len()].copy_from_slice(&encoded);
            bytes
        };

        ext::block_hash(&block_number, output);
        H256::from_slice(output)
    }

    fn block_author(&mut self) -> Address {
        let h160 = {
            let mut scope = self.scoped_buffer();
            let h160: &mut [u8; 20] = scope.take(20).try_into().unwrap();
            ext::block_author(h160);
            *h160
        };
        h160.into()
    }

    fn call_data_load(&mut self, offset: u32) -> U256 {
        let mut scope = self.scoped_buffer();
        let u256: &mut [u8; 32] = scope.take(32).try_into().unwrap();

        ext::call_data_load(u256, offset);
        U256::from_le_bytes(*u256)
    }

    fn set_storage(&mut self, key: U256, value: &[u8; 32]) -> Option<u32> {
        let mut scope = self.scoped_buffer();
        let key: &mut [u8; 32] = scope.take_encoded(&key).try_into().unwrap();
        ext::set_storage_or_clear(STORAGE_FLAGS, key, value)
    }

    fn set_transient_storage(&mut self, key: U256, value: &[u8; 32]) -> Option<u32> {
        let mut scope = self.scoped_buffer();
        let key: &mut [u8; 32] = scope.take_encoded(&key).try_into().unwrap();
        ext::set_storage_or_clear(TRANSIENT_STORAGE_FLAGS, key, value)
    }

    fn get_storage(&mut self, key: U256) -> [u8; 32] {
        let mut scope = self.scoped_buffer();
        let key: &mut [u8; 32] = scope.take_encoded(&key).try_into().unwrap();
        let value: &mut [u8; 32] = scope.take(32).try_into().unwrap();
        ext::get_storage_or_zero(STORAGE_FLAGS, key, value);
        *value
    }

    fn get_transient_storage(&mut self, key: U256) -> [u8; 32] {
        let mut scope = self.scoped_buffer();
        let key: &mut [u8; 32] = scope.take_encoded(&key).try_into().unwrap();
        let value: &mut [u8; 32] = scope.take(32).try_into().unwrap();
        ext::get_storage_or_zero(TRANSIENT_STORAGE_FLAGS, key, value);
        *value
    }

    fn transferred_value(&mut self) -> U256 {
        let mut scope = self.scoped_buffer();
        let u256: &mut [u8; 32] = scope.take(32).try_into().unwrap();

        ext::value_transferred(u256);
        U256::from_le_bytes(*u256)
    }

    fn block_timestamp<E: Environment>(&mut self) -> E::Timestamp {
        self.get_property_little_endian::<E::Timestamp>(ext::now)
    }

    fn account_id<E: Environment>(&mut self) -> E::AccountId {
        let h160 = {
            let mut scope = self.scoped_buffer();
            let h160: &mut [u8; 20] = scope.take(20).try_into().unwrap();
            ext::address(h160);
            *h160
        };
        self.to_account_id::<E>(h160.into())
    }

    fn to_account_id<E: Environment>(&mut self, addr: Address) -> E::AccountId {
        let mut scope = self.scoped_buffer();
        let output: &mut [u8; 32 + SOL_BYTES_ENCODING_OVERHEAD] = scope
            .take(32 + SOL_BYTES_ENCODING_OVERHEAD)
            .try_into()
            .unwrap();
        let addr = addr.as_fixed_bytes();

        const ADDR: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000900");

        let mut input = [0u8; 32 + 4];
        let sel = const { solidity_selector("toAccountId(address)") };
        input[..4].copy_from_slice(&sel[..4]);
        input[16..36].copy_from_slice(&addr[..]);

        let _ = ext::call(
            CallFlags::empty(),
            &ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &input[..],
            Some(&mut &mut output[..]),
        );

        let account_id: &mut [u8; 32] = scope.take(32).try_into().unwrap();
        let n = decode_bytes(&output[..], &mut account_id[..]);
        debug_assert_eq!(n, 32, "length of decoded bytes must be 32");
        scale::Decode::decode(&mut &account_id[..])
            .expect("A contract being executed must have a valid account id.")
    }

    fn address(&mut self) -> Address {
        let mut scope = self.scoped_buffer();
        let h160: &mut [u8; 20] = scope.take(20).try_into().unwrap();
        ext::address(h160);
        Address::from_slice(h160)
    }

    fn balance(&mut self) -> U256 {
        self.get_property_little_endian(ext::balance)
    }

    fn block_number<E: Environment>(&mut self) -> E::BlockNumber {
        self.get_property_little_endian::<E::BlockNumber>(ext::block_number)
    }

    fn minimum_balance(&mut self) -> U256 {
        let selector = const { solidity_selector("minimumBalance()") };
        let output: &mut [u8; 32] = &mut self
            .scoped_buffer()
            .take_max_encoded_len::<U256>()
            .try_into()
            .unwrap();

        const ADDR: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000900");
        ext::call(
            CallFlags::empty(),
            &ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &selector[..],
            Some(&mut &mut output[..]),
        )
        .expect("call host function failed");

        U256::from_big_endian(&output[..])
    }

    fn emit_event<Evt, Abi>(&mut self, event: &Evt)
    where
        Evt: Event<Abi>,
        Abi: TopicEncoder,
    {
        let (mut scope, enc_topics) =
            event.topics(TopicsBuilder::from(self.scoped_buffer()).into());
        // TODO: improve
        let enc_topics = enc_topics
            .chunks_exact(32)
            .map(|c| c.try_into().unwrap())
            .collect::<ink_prelude::vec::Vec<[u8; 32]>>();
        let enc_data = scope.take_encoded_with(|buffer| {
            let encoded = event.encode_data();
            let len = encoded.len();
            // NOTE: panics if buffer isn't large enough.
            // This behavior is similar to `ScopedBuffer::take_encoded`.
            buffer[..len].copy_from_slice(&encoded);
            len
        });

        ext::deposit_event(&enc_topics[..], enc_data);
    }

    fn invoke_contract<E, Args, R, Abi>(
        &mut self,
        params: &CallParams<E, Call, Args, R, Abi>,
    ) -> Result<ink_primitives::MessageResult<R>>
    where
        E: Environment,
        Args: EncodeArgsWith<Abi>,
        R: DecodeMessageResult<Abi>,
    {
        let mut scope = self.scoped_buffer();
        let ref_time_limit = params.ref_time_limit();
        let proof_size_limit = params.proof_size_limit();
        let storage_deposit_limit = params.storage_deposit_limit();

        let enc_storage_limit = to_u256(&mut scope, storage_deposit_limit);

        let enc_callee: &[u8; 20] = params.callee().as_ref().try_into().unwrap();
        let mut enc_transferred_value = EncodeScope::from(scope.take(32));
        scale::Encode::encode_to(&params.transferred_value(), &mut enc_transferred_value);
        let enc_transferred_value: &mut [u8; 32] =
            enc_transferred_value.into_buffer().try_into().unwrap();
        let call_flags = params.call_flags();
        let enc_input = if !call_flags.contains(CallFlags::FORWARD_INPUT)
            && !call_flags.contains(CallFlags::CLONE_INPUT)
        {
            scope.take_encoded_with(|buffer| params.exec_input().encode_to_slice(buffer))
        } else {
            &mut []
        };
        let output = &mut scope.take_rest();
        let flags = params.call_flags();
        let call_result = ext::call(
            *flags,
            enc_callee,
            ref_time_limit,
            proof_size_limit,
            &enc_storage_limit,
            enc_transferred_value,
            enc_input,
            Some(output),
        );
        match call_result {
            Ok(()) => R::decode_output(output, false),
            Err(ReturnErrorCode::CalleeReverted) => R::decode_output(output, true),
            Err(actual_error) => Err(actual_error.into()),
        }
    }

    fn invoke_contract_delegate<E, Args, R, Abi>(
        &mut self,
        params: &CallParams<E, DelegateCall, Args, R, Abi>,
    ) -> Result<ink_primitives::MessageResult<R>>
    where
        E: Environment,
        Args: EncodeArgsWith<Abi>,
        R: DecodeMessageResult<Abi>,
    {
        let mut scope = self.scoped_buffer();
        let call_flags = params.call_flags();
        let enc_input = if !call_flags.contains(CallFlags::FORWARD_INPUT)
            && !call_flags.contains(CallFlags::CLONE_INPUT)
        {
            scope.take_encoded_with(|buffer| params.exec_input().encode_to_slice(buffer))
        } else {
            &mut []
        };
        let deposit_limit = params.deposit_limit();
        let deposit_limit = remove_option(&mut scope, *deposit_limit);

        let output = &mut scope.take_rest();
        let flags = params.call_flags();
        let enc_address: [u8; 20] = params.address().0;
        let ref_time_limit = params.ref_time_limit();
        let proof_size_limit = params.proof_size_limit();
        let call_result = ext::delegate_call(
            *flags,
            &enc_address,
            ref_time_limit,
            proof_size_limit,
            &deposit_limit,
            enc_input,
            Some(output),
        );
        match call_result {
            Ok(()) => R::decode_output(output, false),
            Err(ReturnErrorCode::CalleeReverted) => R::decode_output(output, true),
            Err(actual_error) => Err(actual_error.into()),
        }
    }

    fn instantiate_contract<E, ContractRef, Args, RetType, Abi>(
        &mut self,
        params: &CreateParams<E, ContractRef, LimitParamsV2, Args, RetType, Abi>,
    ) -> Result<
        ink_primitives::ConstructorResult<
            <RetType as ConstructorReturnType<ContractRef, Abi>>::Output,
        >,
    >
    where
        E: Environment,
        ContractRef: FromAddr,
        Args: EncodeArgsWith<Abi>,
        RetType: ConstructorReturnType<ContractRef, Abi>,
    {
        let mut scoped = self.scoped_buffer();

        let ref_time_limit = params.ref_time_limit();
        let proof_size_limit = params.proof_size_limit();
        let storage_deposit_limit = params.storage_deposit_limit().map(|limit| {
            let mut enc_storage_limit = EncodeScope::from(scoped.take(32));
            scale::Encode::encode_to(&limit, &mut enc_storage_limit);
            let enc_storage_limit: [u8; 32] =
                enc_storage_limit.into_buffer().try_into().unwrap();
            enc_storage_limit
        });
        let enc_storage_limit = remove_option(&mut scoped, storage_deposit_limit);

        // todo encodings here are mostly unnecessary, as the type is already 32 bytes
        let enc_code_hash: &mut [u8; 32] = scoped
            .take_encoded(params.code_hash())
            .try_into()
            .expect("unable to take 32 for code_hash");
        let mut enc_endowment = EncodeScope::from(scoped.take(32));
        scale::Encode::encode_to(&params.endowment(), &mut enc_endowment);
        let enc_endowment: &mut [u8; 32] =
            enc_endowment.into_buffer().try_into().unwrap();
        let enc_input = scoped
            .take_encoded_with(|buffer| params.exec_input().encode_to_slice(buffer));
        let mut out_address: [u8; 20] =
            scoped.take(20).try_into().expect("unable to take 20");
        let salt = params.salt_bytes().as_ref();

        let input_and_code_hash = scoped.take(32 + enc_input.len());
        input_and_code_hash[..32].copy_from_slice(enc_code_hash);
        input_and_code_hash[32..].copy_from_slice(enc_input);

        let mut output_data = &mut scoped.take_rest();

        let instantiate_result = ext::instantiate(
            ref_time_limit,
            proof_size_limit,
            &enc_storage_limit,
            enc_endowment,
            input_and_code_hash,
            Some(&mut out_address),
            Some(&mut output_data),
            salt,
        );

        crate::engine::decode_instantiate_result::<_, ContractRef, RetType, Abi>(
            instantiate_result.map_err(Into::into),
            &mut &out_address[..],
            &output_data[..],
        )
    }

    #[cfg(feature = "unstable-hostfn")]
    fn terminate_contract(&mut self, beneficiary: Address) -> ! {
        let buffer: &mut [u8; 20] = self.scoped_buffer().take_encoded(&beneficiary)
            [0..20]
            .as_mut()
            .try_into()
            .unwrap();
        ext::terminate(buffer);
    }

    fn transfer<E>(&mut self, destination: Address, value: U256) -> Result<()>
    where
        E: Environment,
    {
        let mut scope = self.scoped_buffer();
        let enc_callee: &[u8; 20] = destination.as_ref().try_into().unwrap();
        let mut enc_value = EncodeScope::from(scope.take(32));
        scale::Encode::encode_to(&value, &mut enc_value);
        let enc_value: &mut [u8; 32] = enc_value.into_buffer().try_into().unwrap();

        let mut enc_limit = EncodeScope::from(scope.take(32));
        scale::Encode::encode_to(&U256::MAX, &mut enc_limit);
        let enc_limit: &mut [u8; 32] = enc_limit.into_buffer().try_into().unwrap();

        let output = &mut scope.take_rest();
        #[allow(deprecated)]
        let call_result = ext::call(
            CallFlags::empty(),
            enc_callee,
            u64::MAX,
            u64::MAX,
            enc_limit,
            enc_value,
            &[],
            Some(output),
        );
        match call_result {
            Ok(()) => {
                // TODO: clean comments?
                // no need to decode, is ()
                Ok(())
            }
            Err(actual_error) => Err(actual_error.into()),
        }
    }

    fn weight_to_fee(&mut self, gas: u64) -> U256 {
        let mut scope = self.scoped_buffer();
        let u256: &mut [u8; 32] = scope.take(32).try_into().unwrap();
        ext::weight_to_fee(gas, gas, u256);
        U256::from_le_bytes(*u256)
    }

    fn is_contract(&mut self, addr: &Address) -> bool {
        ext::code_size(&addr.0) > 0
    }

    fn caller_is_origin(&mut self) -> bool {
        let sel = const { solidity_selector("callerIsOrigin()") };
        let output: &mut [u8; 32] =
            &mut self.scoped_buffer().take(32).try_into().unwrap();
        call_bool_precompile(sel, output)
    }

    fn caller_is_root(&mut self) -> bool {
        let sel = const { solidity_selector("callerIsRoot()") };
        let output: &mut [u8; 32] =
            &mut self.scoped_buffer().take(32).try_into().unwrap();
        call_bool_precompile(sel, output)
    }

    fn code_hash(&mut self, addr: &Address) -> core::result::Result<H256, CodeHashErr> {
        let mut scope = self.scoped_buffer();
        let output: &mut [u8; 32] =
            scope.take_max_encoded_len::<H256>().try_into().unwrap();
        ext::code_hash(&addr.0, output);
        let hash = H256::from_slice(output);
        // If not a contract, but account exists, then `keccak_256([])` is returned.
        // Otherwise `zero`.
        if hash == H256_ZERO {
            Err(CodeHashErr::AddressNotFound)
        } else if hash == EMPTY_CODE_HASH {
            Err(CodeHashErr::NotContractButAccount)
        } else {
            Ok(hash)
        }
    }

    fn own_code_hash(&mut self) -> H256 {
        let sel = const { solidity_selector("ownCodeHash()") };
        let output: &mut [u8; 32] = &mut self
            .scoped_buffer()
            .take_max_encoded_len::<H256>()
            .try_into()
            .unwrap();

        const ADDR: [u8; 20] =
            hex_literal::hex!("0000000000000000000000000000000000000900");
        let call_result = ext::call(
            CallFlags::empty(),
            &ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &sel[..],
            Some(&mut &mut output[..]),
        );
        call_result.expect("call host function failed");
        H256::from_slice(output)
    }

    #[cfg(feature = "xcm")]
    fn xcm_weigh<Call>(&mut self, msg: &VersionedXcm<Call>) -> Result<Weight>
    where
        Call: scale::Encode,
    {
        let mut scope = self.scoped_buffer();
        let enc_msg = scope.take_encoded(msg);
        let buffer = scope.take_rest();

        let mut output_buffer = [0u8; 64];

        let sel = const { solidity_selector("weighMessage(bytes)") };
        buffer[..4].copy_from_slice(&sel[..4]);

        let n = solidity_encode_bytes(enc_msg, 32, 0, &mut buffer[4..]);

        let call_result = ext::call(
            CallFlags::empty(),
            &XCM_PRECOMPILE_ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &buffer[..4 + n],
            Some(&mut &mut output_buffer[..]),
        );
        call_result.expect("call host function failed");

        let mut ref_time_bytes = [0u8; 8];
        ref_time_bytes.copy_from_slice(&output_buffer[24..32]);
        let mut proof_size_bytes = [0u8; 8];
        proof_size_bytes.copy_from_slice(&output_buffer[56..64]);

        let weight: Weight = Weight::from_parts(
            u64::from_be_bytes(ref_time_bytes),
            u64::from_be_bytes(proof_size_bytes),
        );
        Ok(weight)
    }

    #[cfg(feature = "xcm")]
    fn xcm_execute<Call>(
        &mut self,
        msg: &VersionedXcm<Call>,
        weight: Weight,
    ) -> Result<()>
    where
        Call: scale::Encode,
    {
        let mut scope = self.scoped_buffer();
        let enc_msg = scope.take_encoded(msg);
        let buffer = scope.take_rest();

        let sel = const { solidity_selector("execute(bytes,(uint64,uint64))") };
        buffer[..4].copy_from_slice(&sel[..4]);

        // 96 because 64 for `Weight` and 32 for `bytes` offset
        let n = solidity_encode_bytes(enc_msg, 96, 0, &mut buffer[4..]);

        let mut weight_bytes = [0u8; 64];
        weight_bytes[24..32].copy_from_slice(&weight.ref_time().to_be_bytes());
        weight_bytes[56..64].copy_from_slice(&weight.proof_size().to_be_bytes());
        // put the `Weight` after the `bytes` offset word
        buffer[4 + 32..4 + 32 + 64].copy_from_slice(&weight_bytes[..]);

        let _call_result = ext::call(
            CallFlags::empty(),
            &XCM_PRECOMPILE_ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &buffer[..4 + n + 64],
            None,
        )?;
        Ok(())
    }

    #[cfg(feature = "xcm")]
    fn xcm_send<Call>(
        &mut self,
        dest: &xcm::VersionedLocation,
        msg: &VersionedXcm<Call>,
    ) -> Result<()>
    where
        Call: scale::Encode,
    {
        let mut scope = self.scoped_buffer();
        let enc_dest = scope.take_encoded(dest);
        let enc_msg = scope.take_encoded(msg);

        let buffer = scope.take_rest();

        let sel = const { solidity_selector("send(bytes,bytes)") };
        buffer[..4].copy_from_slice(&sel[..4]);

        let n_dest = solidity_encode_bytes(enc_dest, 64, 0, &mut buffer[4..]);
        let n_msg = solidity_encode_bytes(
            enc_msg,
            32 /* first `bytes` offset word  */ +
            32 /* second `bytes` offset word */ +
            (n_dest  - 32usize) as u32, /* we have to subtract 32, because that's the
                                         * length of the `offset` word */
            32, // the offset word is written right after the offset word for `dest`
            &mut buffer[4..],
        );

        let call_result = ext::call(
            CallFlags::empty(),
            &XCM_PRECOMPILE_ADDR,
            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
            &[u8::MAX; 32], // No deposit limit.
            &U256::zero().to_little_endian(), // Value transferred to the contract.
            &buffer[..4 + n_dest + n_msg],
            None,
        );
        call_result.expect("calling host function failed");
        Ok(())
    }
}

// todo make this const
fn to_u256(scope: &mut ScopedBuffer, value: Option<U256>) -> [u8; 32] {
    let limit = match value {
        None => U256::MAX,
        Some(u256) => u256,
    };
    let mut enc_storage_limit = EncodeScope::from(scope.take(32));
    scale::Encode::encode_to(&limit, &mut enc_storage_limit);
    let enc_storage_limit: [u8; 32] = enc_storage_limit.into_buffer().try_into().unwrap();
    enc_storage_limit
}

fn remove_option(scope: &mut ScopedBuffer, opt: Option<[u8; 32]>) -> [u8; 32] {
    match opt {
        None => {
            let limit = U256::MAX; // corresponds to no deposit limit, defined in `pallet-revive`
            let mut enc_storage_limit = EncodeScope::from(scope.take(32));
            scale::Encode::encode_to(&limit, &mut enc_storage_limit);
            let enc_storage_limit: [u8; 32] =
                enc_storage_limit.into_buffer().try_into().unwrap();
            enc_storage_limit
        }
        Some(bytes) => bytes,
    }
}