// Copyright 2015-2019 Parity Technologies (UK) Ltd.
// This file is part of Parity Ethereum.

// Parity Ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Parity Ethereum is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Parity Ethereum.  If not, see <http://www.gnu.org/licenses/>.

use super::panic_payload;
use ethereum_types::{Address, H256, U256};
use std::cmp;
use vm::{self, CallType};
use wasmi::{
    self, Error as InterpreterError, MemoryRef, RuntimeArgs, RuntimeValue, Trap, TrapKind,
};

pub struct RuntimeContext {
    pub address: Address,
    pub sender: Address,
    pub origin: Address,
    pub code_address: Address,
    pub value: U256,
}

pub struct Runtime<'a> {
    gas_counter: u64,
    gas_limit: u64,
    ext: &'a mut dyn vm::Ext,
    context: RuntimeContext,
    memory: MemoryRef,
    args: Vec<u8>,
    result: Vec<u8>,
}

/// User trap in native code
#[derive(Debug, Clone, PartialEq)]
pub enum Error {
    /// Storage read error
    StorageReadError,
    /// Storage update error
    StorageUpdateError,
    /// Memory access violation
    MemoryAccessViolation,
    /// Native code resulted in suicide
    Suicide,
    /// Native code requested execution to finish
    Return,
    /// Suicide was requested but coudn't complete
    SuicideAbort,
    /// Invalid gas state inside interpreter
    InvalidGasState,
    /// Query of the balance resulted in an error
    BalanceQueryError,
    /// Failed allocation
    AllocationFailed,
    /// Gas limit reached
    GasLimit,
    /// Unknown runtime function
    Unknown,
    /// Passed string had invalid utf-8 encoding
    BadUtf8,
    /// Log event error
    Log,
    /// Other error in native code
    Other,
    /// Syscall signature mismatch
    InvalidSyscall,
    /// Unreachable instruction encountered
    Unreachable,
    /// Invalid virtual call
    InvalidVirtualCall,
    /// Division by zero
    DivisionByZero,
    /// Invalid conversion to integer
    InvalidConversionToInt,
    /// Stack overflow
    StackOverflow,
    /// Panic with message
    Panic(String),
}

impl wasmi::HostError for Error {}

impl From<Trap> for Error {
    fn from(trap: Trap) -> Self {
        match *trap.kind() {
            TrapKind::Unreachable => Error::Unreachable,
            TrapKind::MemoryAccessOutOfBounds => Error::MemoryAccessViolation,
            TrapKind::TableAccessOutOfBounds | TrapKind::ElemUninitialized => {
                Error::InvalidVirtualCall
            }
            TrapKind::DivisionByZero => Error::DivisionByZero,
            TrapKind::InvalidConversionToInt => Error::InvalidConversionToInt,
            TrapKind::UnexpectedSignature => Error::InvalidVirtualCall,
            TrapKind::StackOverflow => Error::StackOverflow,
            TrapKind::Host(_) => Error::Other,
        }
    }
}

impl From<InterpreterError> for Error {
    fn from(err: InterpreterError) -> Self {
        match err {
            InterpreterError::Value(_) => Error::InvalidSyscall,
            InterpreterError::Memory(_) => Error::MemoryAccessViolation,
            _ => Error::Other,
        }
    }
}

impl ::std::fmt::Display for Error {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> {
        match *self {
            Error::StorageReadError => write!(f, "Storage read error"),
            Error::StorageUpdateError => write!(f, "Storage update error"),
            Error::MemoryAccessViolation => write!(f, "Memory access violation"),
            Error::SuicideAbort => write!(f, "Attempt to suicide resulted in an error"),
            Error::InvalidGasState => write!(f, "Invalid gas state"),
            Error::BalanceQueryError => write!(f, "Balance query resulted in an error"),
            Error::Suicide => write!(f, "Suicide result"),
            Error::Return => write!(f, "Return result"),
            Error::Unknown => write!(f, "Unknown runtime function invoked"),
            Error::AllocationFailed => write!(f, "Memory allocation failed (OOM)"),
            Error::BadUtf8 => write!(f, "String encoding is bad utf-8 sequence"),
            Error::GasLimit => write!(f, "Invocation resulted in gas limit violated"),
            Error::Log => write!(f, "Error occured while logging an event"),
            Error::InvalidSyscall => write!(f, "Invalid syscall signature encountered at runtime"),
            Error::Other => write!(f, "Other unspecified error"),
            Error::Unreachable => write!(f, "Unreachable instruction encountered"),
            Error::InvalidVirtualCall => write!(f, "Invalid virtual call"),
            Error::DivisionByZero => write!(f, "Division by zero"),
            Error::StackOverflow => write!(f, "Stack overflow"),
            Error::InvalidConversionToInt => write!(f, "Invalid conversion to integer"),
            Error::Panic(ref msg) => write!(f, "Panic: {}", msg),
        }
    }
}

type Result<T> = ::std::result::Result<T, Error>;

impl<'a> Runtime<'a> {
    /// New runtime for wasm contract with specified params
    pub fn with_params(
        ext: &mut dyn vm::Ext,
        memory: MemoryRef,
        gas_limit: u64,
        args: Vec<u8>,
        context: RuntimeContext,
    ) -> Runtime {
        Runtime {
            gas_counter: 0,
            gas_limit: gas_limit,
            memory: memory,
            ext: ext,
            context: context,
            args: args,
            result: Vec::new(),
        }
    }

    /// Loads 256-bit hash from the specifed sandboxed memory pointer
    fn h256_at(&self, ptr: u32) -> Result<H256> {
        let mut buf = [0u8; 32];
        self.memory.get_into(ptr, &mut buf[..])?;

        Ok(H256::from(&buf[..]))
    }

    /// Loads 160-bit hash (Ethereum address) from the specified sandboxed memory pointer
    fn address_at(&self, ptr: u32) -> Result<Address> {
        let mut buf = [0u8; 20];
        self.memory.get_into(ptr, &mut buf[..])?;

        Ok(Address::from(&buf[..]))
    }

    /// Loads 256-bit integer represented with bigendian from the specified sandboxed memory pointer
    fn u256_at(&self, ptr: u32) -> Result<U256> {
        let mut buf = [0u8; 32];
        self.memory.get_into(ptr, &mut buf[..])?;

        Ok(U256::from_big_endian(&buf[..]))
    }

    /// Charge specified amount of gas
    ///
    /// Returns false if gas limit exceeded and true if not.
    /// Intuition about the return value sense is to aswer the question 'are we allowed to continue?'
    fn charge_gas(&mut self, amount: u64) -> bool {
        let prev = self.gas_counter;
        match prev.checked_add(amount) {
            // gas charge overflow protection
            None => false,
            Some(val) if val > self.gas_limit => false,
            Some(_) => {
                self.gas_counter = prev + amount;
                true
            }
        }
    }

    /// Charge gas according to closure
    pub fn charge<F>(&mut self, f: F) -> Result<()>
    where
        F: FnOnce(&vm::Schedule) -> u64,
    {
        let amount = f(self.ext.schedule());
        if !self.charge_gas(amount as u64) {
            Err(Error::GasLimit)
        } else {
            Ok(())
        }
    }

    /// Adjusted charge of gas which scales actual charge according to the wasm opcode counting coefficient
    pub fn adjusted_charge<F>(&mut self, f: F) -> Result<()>
    where
        F: FnOnce(&vm::Schedule) -> u64,
    {
        self.charge(|schedule| {
            f(schedule) * schedule.wasm().opcodes_div as u64 / schedule.wasm().opcodes_mul as u64
        })
    }

    /// Charge gas provided by the closure
    ///
    /// Closure also can return overflowing flag as None in gas cost.
    pub fn overflow_charge<F>(&mut self, f: F) -> Result<()>
    where
        F: FnOnce(&vm::Schedule) -> Option<u64>,
    {
        let amount = match f(self.ext.schedule()) {
            Some(amount) => amount,
            None => {
                return Err(Error::GasLimit.into());
            }
        };

        if !self.charge_gas(amount as u64) {
            Err(Error::GasLimit.into())
        } else {
            Ok(())
        }
    }

    /// Same as overflow_charge, but with amount adjusted by wasm opcodes coeff
    pub fn adjusted_overflow_charge<F>(&mut self, f: F) -> Result<()>
    where
        F: FnOnce(&vm::Schedule) -> Option<u64>,
    {
        self.overflow_charge(|schedule| {
            f(schedule)
                .and_then(|x| x.checked_mul(schedule.wasm().opcodes_div as u64))
                .map(|x| x / schedule.wasm().opcodes_mul as u64)
        })
    }

    /// Read from the storage to wasm memory
    pub fn storage_read(&mut self, args: RuntimeArgs) -> Result<()> {
        let key = self.h256_at(args.nth_checked(0)?)?;
        let val_ptr: u32 = args.nth_checked(1)?;

        let val = self
            .ext
            .storage_at(&key)
            .map_err(|_| Error::StorageReadError)?;

        self.adjusted_charge(|schedule| schedule.sload_gas as u64)?;

        self.memory.set(val_ptr as u32, &*val)?;

        Ok(())
    }

    /// Write to storage from wasm memory
    pub fn storage_write(&mut self, args: RuntimeArgs) -> Result<()> {
        let key = self.h256_at(args.nth_checked(0)?)?;
        let val_ptr: u32 = args.nth_checked(1)?;

        let val = self.h256_at(val_ptr)?;
        let former_val = self
            .ext
            .storage_at(&key)
            .map_err(|_| Error::StorageUpdateError)?;

        if former_val == H256::zero() && val != H256::zero() {
            self.adjusted_charge(|schedule| schedule.sstore_set_gas as u64)?;
        } else {
            self.adjusted_charge(|schedule| schedule.sstore_reset_gas as u64)?;
        }

        self.ext
            .set_storage(key, val)
            .map_err(|_| Error::StorageUpdateError)?;

        if former_val != H256::zero() && val == H256::zero() {
            let sstore_clears_schedule = self.schedule().sstore_refund_gas;
            self.ext.add_sstore_refund(sstore_clears_schedule);
        }

        Ok(())
    }

    /// Return currently used schedule
    pub fn schedule(&self) -> &vm::Schedule {
        self.ext.schedule()
    }

    /// Sets a return value for the call
    ///
    /// Syscall takes 2 arguments:
    /// * pointer in sandboxed memory where result is
    /// * the length of the result
    pub fn ret(&mut self, args: RuntimeArgs) -> Result<()> {
        let ptr: u32 = args.nth_checked(0)?;
        let len: u32 = args.nth_checked(1)?;

        trace!(target: "wasm", "Contract ret: {} bytes @ {}", len, ptr);

        self.result = self.memory.get(ptr, len as usize)?;

        Err(Error::Return)
    }

    /// Destroy the runtime, returning currently recorded result of the execution
    pub fn into_result(self) -> Vec<u8> {
        self.result
    }

    /// Query current gas left for execution
    pub fn gas_left(&self) -> Result<u64> {
        if self.gas_counter > self.gas_limit {
            return Err(Error::InvalidGasState);
        }
        Ok(self.gas_limit - self.gas_counter)
    }

    /// General gas charging extern.
    fn gas(&mut self, args: RuntimeArgs) -> Result<()> {
        let amount: u32 = args.nth_checked(0)?;
        if self.charge_gas(amount as u64) {
            Ok(())
        } else {
            Err(Error::GasLimit.into())
        }
    }

    /// Query the length of the input bytes
    fn input_legnth(&mut self) -> RuntimeValue {
        RuntimeValue::I32(self.args.len() as i32)
    }

    /// Write input bytes to the memory location using the passed pointer
    fn fetch_input(&mut self, args: RuntimeArgs) -> Result<()> {
        let ptr: u32 = args.nth_checked(0)?;

        let args_len = self.args.len() as u64;
        self.charge(|s| args_len * s.wasm().memcpy as u64)?;

        self.memory.set(ptr, &self.args[..])?;
        Ok(())
    }

    /// User panic
    ///
    /// Contract can invoke this when he encounters unrecoverable error.
    fn panic(&mut self, args: RuntimeArgs) -> Result<()> {
        let payload_ptr: u32 = args.nth_checked(0)?;
        let payload_len: u32 = args.nth_checked(1)?;

        let raw_payload = self.memory.get(payload_ptr, payload_len as usize)?;
        let payload = panic_payload::decode(&raw_payload);
        let msg = format!(
            "{msg}, {file}:{line}:{col}",
            msg = payload
                .msg
                .as_ref()
                .map(String::as_ref)
                .unwrap_or("<msg was stripped>"),
            file = payload
                .file
                .as_ref()
                .map(String::as_ref)
                .unwrap_or("<unknown>"),
            line = payload.line.unwrap_or(0),
            col = payload.col.unwrap_or(0)
        );
        trace!(target: "wasm", "Contract custom panic message: {}", msg);

        Err(Error::Panic(msg).into())
    }

    fn do_call(
        &mut self,
        use_val: bool,
        call_type: CallType,
        args: RuntimeArgs,
    ) -> Result<RuntimeValue> {
        trace!(target: "wasm", "runtime: CALL({:?})", call_type);

        let gas: u64 = args.nth_checked(0)?;
        trace!(target: "wasm", "           gas: {:?}", gas);

        let address = self.address_at(args.nth_checked(1)?)?;
        trace!(target: "wasm", "       address: {:?}", address);

        let vofs = if use_val { 1 } else { 0 };
        let val = if use_val {
            Some(self.u256_at(args.nth_checked(2)?)?)
        } else {
            None
        };
        trace!(target: "wasm", "           val: {:?}", val);

        let input_ptr: u32 = args.nth_checked(2 + vofs)?;
        trace!(target: "wasm", "     input_ptr: {:?}", input_ptr);

        let input_len: u32 = args.nth_checked(3 + vofs)?;
        trace!(target: "wasm", "     input_len: {:?}", input_len);

        let result_ptr: u32 = args.nth_checked(4 + vofs)?;
        trace!(target: "wasm", "    result_ptr: {:?}", result_ptr);

        let result_alloc_len: u32 = args.nth_checked(5 + vofs)?;
        trace!(target: "wasm", "    result_len: {:?}", result_alloc_len);

        if let Some(ref val) = val {
            let address_balance = self
                .ext
                .balance(&self.context.address)
                .map_err(|_| Error::BalanceQueryError)?;

            if &address_balance < val {
                trace!(target: "wasm", "runtime: call failed due to balance check");
                return Ok((-1i32).into());
            }
        }

        self.adjusted_charge(|schedule| schedule.call_gas as u64)?;

        let mut result = Vec::with_capacity(result_alloc_len as usize);
        result.resize(result_alloc_len as usize, 0);

        // todo: optimize to use memory views once it's in
        let payload = self.memory.get(input_ptr, input_len as usize)?;

        let adjusted_gas = match gas
            .checked_mul(self.ext.schedule().wasm().opcodes_div as u64)
            .map(|x| x / self.ext.schedule().wasm().opcodes_mul as u64)
        {
            Some(x) => x,
            None => {
                trace!("CALL overflowed gas, call aborted with error returned");
                return Ok(RuntimeValue::I32(-1));
            }
        };

        self.charge(|_| adjusted_gas)?;

        let call_result = self
            .ext
            .call(
                &gas.into(),
                match call_type {
                    CallType::DelegateCall => &self.context.sender,
                    _ => &self.context.address,
                },
                match call_type {
                    CallType::Call | CallType::StaticCall => &address,
                    _ => &self.context.address,
                },
                val,
                &payload,
                &address,
                call_type,
                false,
            )
            .ok()
            .expect("Trap is false; trap error will not happen; qed");

        match call_result {
            vm::MessageCallResult::Success(gas_left, data) => {
                let len = cmp::min(result.len(), data.len());
                (&mut result[..len]).copy_from_slice(&data[..len]);

                // cannot overflow, before making call gas_counter was incremented with gas, and gas_left < gas
                self.gas_counter = self.gas_counter
                    - gas_left.low_u64() * self.ext.schedule().wasm().opcodes_div as u64
                        / self.ext.schedule().wasm().opcodes_mul as u64;

                self.memory.set(result_ptr, &result)?;
                Ok(0i32.into())
            }
            vm::MessageCallResult::Reverted(gas_left, data) => {
                let len = cmp::min(result.len(), data.len());
                (&mut result[..len]).copy_from_slice(&data[..len]);

                // cannot overflow, before making call gas_counter was incremented with gas, and gas_left < gas
                self.gas_counter = self.gas_counter
                    - gas_left.low_u64() * self.ext.schedule().wasm().opcodes_div as u64
                        / self.ext.schedule().wasm().opcodes_mul as u64;

                self.memory.set(result_ptr, &result)?;
                Ok((-1i32).into())
            }
            vm::MessageCallResult::Failed => Ok((-1i32).into()),
        }
    }

    /// Message call
    fn ccall(&mut self, args: RuntimeArgs) -> Result<RuntimeValue> {
        self.do_call(true, CallType::Call, args)
    }

    /// Delegate call
    fn dcall(&mut self, args: RuntimeArgs) -> Result<RuntimeValue> {
        self.do_call(false, CallType::DelegateCall, args)
    }

    /// Static call
    fn scall(&mut self, args: RuntimeArgs) -> Result<RuntimeValue> {
        self.do_call(false, CallType::StaticCall, args)
    }

    fn return_address_ptr(&mut self, ptr: u32, val: Address) -> Result<()> {
        self.charge(|schedule| schedule.wasm().static_address as u64)?;
        self.memory.set(ptr, &*val)?;
        Ok(())
    }

    fn return_u256_ptr(&mut self, ptr: u32, val: U256) -> Result<()> {
        let value: H256 = val.into();
        self.charge(|schedule| schedule.wasm().static_u256 as u64)?;
        self.memory.set(ptr, &*value)?;
        Ok(())
    }

    /// Returns value (in Wei) passed to contract
    pub fn value(&mut self, args: RuntimeArgs) -> Result<()> {
        let val = self.context.value;
        self.return_u256_ptr(args.nth_checked(0)?, val)
    }

    fn do_create(
        &mut self,
        endowment: U256,
        code_ptr: u32,
        code_len: u32,
        result_ptr: u32,
        scheme: vm::CreateContractAddress,
    ) -> Result<RuntimeValue> {
        let code = self.memory.get(code_ptr, code_len as usize)?;

        self.adjusted_charge(|schedule| schedule.create_gas as u64)?;
        self.adjusted_charge(|schedule| schedule.create_data_gas as u64 * code.len() as u64)?;

        let gas_left: U256 = U256::from(self.gas_left()?)
            * U256::from(self.ext.schedule().wasm().opcodes_mul)
            / U256::from(self.ext.schedule().wasm().opcodes_div);

        match self
            .ext
            .create(&gas_left, &endowment, &code, scheme, false)
            .ok()
            .expect("Trap is false; trap error will not happen; qed")
        {
            vm::ContractCreateResult::Created(address, gas_left) => {
                self.memory.set(result_ptr, &*address)?;
                self.gas_counter = self.gas_limit -
					// this cannot overflow, since initial gas is in [0..u64::max) range,
					// and gas_left cannot be bigger
					gas_left.low_u64() * self.ext.schedule().wasm().opcodes_div as u64
						/ self.ext.schedule().wasm().opcodes_mul as u64;
                trace!(target: "wasm", "runtime: create contract success (@{:?})", address);
                Ok(0i32.into())
            }
            vm::ContractCreateResult::Failed => {
                trace!(target: "wasm", "runtime: create contract fail");
                Ok((-1i32).into())
            }
            vm::ContractCreateResult::Reverted(gas_left, _) => {
                trace!(target: "wasm", "runtime: create contract reverted");
                self.gas_counter = self.gas_limit -
					// this cannot overflow, since initial gas is in [0..u64::max) range,
					// and gas_left cannot be bigger
					gas_left.low_u64() * self.ext.schedule().wasm().opcodes_div as u64
						/ self.ext.schedule().wasm().opcodes_mul as u64;

                Ok((-1i32).into())
            }
        }
    }

    /// Creates a new contract
    ///
    /// Arguments:
    /// * endowment - how much value (in Wei) transfer to the newly created contract
    /// * code_ptr - pointer to the code data
    /// * code_len - lenght of the code data
    /// * result_ptr - pointer to write an address of the newly created contract
    pub fn create(&mut self, args: RuntimeArgs) -> Result<RuntimeValue> {
        //
        // method signature:
        //   fn create(endowment: *const u8, code_ptr: *const u8, code_len: u32, result_ptr: *mut u8) -> i32;
        //
        trace!(target: "wasm", "runtime: CREATE");
        let endowment = self.u256_at(args.nth_checked(0)?)?;
        trace!(target: "wasm", "       val: {:?}", endowment);
        let code_ptr: u32 = args.nth_checked(1)?;
        trace!(target: "wasm", "  code_ptr: {:?}", code_ptr);
        let code_len: u32 = args.nth_checked(2)?;
        trace!(target: "wasm", "  code_len: {:?}", code_len);
        let result_ptr: u32 = args.nth_checked(3)?;
        trace!(target: "wasm", "result_ptr: {:?}", result_ptr);

        self.do_create(
            endowment,
            code_ptr,
            code_len,
            result_ptr,
            vm::CreateContractAddress::FromSenderAndCodeHash,
        )
    }

    /// Creates a new contract using FromSenderSaltAndCodeHash scheme
    ///
    /// Arguments:
    /// * endowment - how much value (in Wei) transfer to the newly created contract
    /// * salt - salt to be used in contract creation address
    /// * code_ptr - pointer to the code data
    /// * code_len - lenght of the code data
    /// * result_ptr - pointer to write an address of the newly created contract
    pub fn create2(&mut self, args: RuntimeArgs) -> Result<RuntimeValue> {
        //
        // method signature:
        //   fn create2(endowment: *const u8, salt: *const u8, code_ptr: *const u8, code_len: u32, result_ptr: *mut u8) -> i32;
        //
        trace!(target: "wasm", "runtime: CREATE2");
        let endowment = self.u256_at(args.nth_checked(0)?)?;
        trace!(target: "wasm", "       val: {:?}", endowment);
        let salt: H256 = self.u256_at(args.nth_checked(1)?)?.into();
        trace!(target: "wasm", "      salt: {:?}", salt);
        let code_ptr: u32 = args.nth_checked(2)?;
        trace!(target: "wasm", "  code_ptr: {:?}", code_ptr);
        let code_len: u32 = args.nth_checked(3)?;
        trace!(target: "wasm", "  code_len: {:?}", code_len);
        let result_ptr: u32 = args.nth_checked(4)?;
        trace!(target: "wasm", "result_ptr: {:?}", result_ptr);

        self.do_create(
            endowment,
            code_ptr,
            code_len,
            result_ptr,
            vm::CreateContractAddress::FromSenderSaltAndCodeHash(salt),
        )
    }

    fn debug(&mut self, args: RuntimeArgs) -> Result<()> {
        trace!(target: "wasm", "Contract debug message: {}", {
            let msg_ptr: u32 = args.nth_checked(0)?;
            let msg_len: u32 = args.nth_checked(1)?;

            String::from_utf8(self.memory.get(msg_ptr, msg_len as usize)?)
                .map_err(|_| Error::BadUtf8)?
        });

        Ok(())
    }

    /// Pass suicide to state runtime
    pub fn suicide(&mut self, args: RuntimeArgs) -> Result<()> {
        let refund_address = self.address_at(args.nth_checked(0)?)?;

        if self
            .ext
            .exists(&refund_address)
            .map_err(|_| Error::SuicideAbort)?
        {
            trace!(target: "wasm", "Suicide: refund to existing address {}", refund_address);
            self.adjusted_charge(|schedule| schedule.suicide_gas as u64)?;
        } else {
            trace!(target: "wasm", "Suicide: refund to new address {}", refund_address);
            self.adjusted_charge(|schedule| schedule.suicide_to_new_account_cost as u64)?;
        }

        self.ext
            .suicide(&refund_address)
            .map_err(|_| Error::SuicideAbort)?;

        // We send trap to interpreter so it should abort further execution
        Err(Error::Suicide.into())
    }

    ///	Signature: `fn blockhash(number: i64, dest: *mut u8)`
    pub fn blockhash(&mut self, args: RuntimeArgs) -> Result<()> {
        self.adjusted_charge(|schedule| schedule.blockhash_gas as u64)?;
        let hash = self.ext.blockhash(&U256::from(args.nth_checked::<u64>(0)?));
        self.memory.set(args.nth_checked(1)?, &*hash)?;

        Ok(())
    }

    ///	Signature: `fn blocknumber() -> i64`
    pub fn blocknumber(&mut self) -> Result<RuntimeValue> {
        Ok(RuntimeValue::from(self.ext.env_info().number))
    }

    ///	Signature: `fn coinbase(dest: *mut u8)`
    pub fn coinbase(&mut self, args: RuntimeArgs) -> Result<()> {
        let coinbase = self.ext.env_info().author;
        self.return_address_ptr(args.nth_checked(0)?, coinbase)
    }

    ///	Signature: `fn difficulty(dest: *mut u8)`
    pub fn difficulty(&mut self, args: RuntimeArgs) -> Result<()> {
        let difficulty = self.ext.env_info().difficulty;
        self.return_u256_ptr(args.nth_checked(0)?, difficulty)
    }

    ///	Signature: `fn gasleft() -> i64`
    pub fn gasleft(&mut self) -> Result<RuntimeValue> {
        Ok(RuntimeValue::from(
            self.gas_left()? * self.ext.schedule().wasm().opcodes_mul as u64
                / self.ext.schedule().wasm().opcodes_div as u64,
        ))
    }

    ///	Signature: `fn gaslimit(dest: *mut u8)`
    pub fn gaslimit(&mut self, args: RuntimeArgs) -> Result<()> {
        let gas_limit = self.ext.env_info().gas_limit;
        self.return_u256_ptr(args.nth_checked(0)?, gas_limit)
    }

    ///	Signature: `fn address(dest: *mut u8)`
    pub fn address(&mut self, args: RuntimeArgs) -> Result<()> {
        let address = self.context.address;
        self.return_address_ptr(args.nth_checked(0)?, address)
    }

    ///	Signature: `sender(dest: *mut u8)`
    pub fn sender(&mut self, args: RuntimeArgs) -> Result<()> {
        let sender = self.context.sender;
        self.return_address_ptr(args.nth_checked(0)?, sender)
    }

    ///	Signature: `origin(dest: *mut u8)`
    pub fn origin(&mut self, args: RuntimeArgs) -> Result<()> {
        let origin = self.context.origin;
        self.return_address_ptr(args.nth_checked(0)?, origin)
    }

    ///	Signature: `timestamp() -> i64`
    pub fn timestamp(&mut self) -> Result<RuntimeValue> {
        let timestamp = self.ext.env_info().timestamp;
        Ok(RuntimeValue::from(timestamp))
    }

    ///	Signature: `fn elog(topic_ptr: *const u8, topic_count: u32, data_ptr: *const u8, data_len: u32)`
    pub fn elog(&mut self, args: RuntimeArgs) -> Result<()> {
        let topic_ptr: u32 = args.nth_checked(0)?;
        let topic_count: u32 = args.nth_checked(1)?;
        let data_ptr: u32 = args.nth_checked(2)?;
        let data_len: u32 = args.nth_checked(3)?;

        if topic_count > 4 {
            return Err(Error::Log.into());
        }

        self.adjusted_overflow_charge(|schedule| {
            let topics_gas =
                schedule.log_gas as u64 + schedule.log_topic_gas as u64 * topic_count as u64;
            (schedule.log_data_gas as u64)
                .checked_mul(schedule.log_data_gas as u64)
                .and_then(|data_gas| data_gas.checked_add(topics_gas))
        })?;

        let mut topics: Vec<H256> = Vec::with_capacity(topic_count as usize);
        topics.resize(topic_count as usize, H256::zero());
        for i in 0..topic_count {
            let offset = i
                .checked_mul(32)
                .ok_or(Error::MemoryAccessViolation)?
                .checked_add(topic_ptr)
                .ok_or(Error::MemoryAccessViolation)?;

            *topics.get_mut(i as usize)
				.expect("topics is resized to `topic_count`, i is in 0..topic count iterator, get_mut uses i as an indexer, get_mut cannot fail; qed")
				= H256::from(&self.memory.get(offset, 32)?[..]);
        }
        self.ext
            .log(topics, &self.memory.get(data_ptr, data_len as usize)?)
            .map_err(|_| Error::Log)?;

        Ok(())
    }
}

mod ext_impl {

    use env::ids::*;
    use wasmi::{Externals, RuntimeArgs, RuntimeValue, Trap};

    macro_rules! void {
		{ $e: expr } => { { $e?; Ok(None) } }
	}

    macro_rules! some {
		{ $e: expr } => { { Ok(Some($e?)) } }
	}

    macro_rules! cast {
		{ $e: expr } => { { Ok(Some($e)) } }
	}

    impl<'a> Externals for super::Runtime<'a> {
        fn invoke_index(
            &mut self,
            index: usize,
            args: RuntimeArgs,
        ) -> Result<Option<RuntimeValue>, Trap> {
            match index {
                STORAGE_WRITE_FUNC => void!(self.storage_write(args)),
                STORAGE_READ_FUNC => void!(self.storage_read(args)),
                RET_FUNC => void!(self.ret(args)),
                GAS_FUNC => void!(self.gas(args)),
                INPUT_LENGTH_FUNC => cast!(self.input_legnth()),
                FETCH_INPUT_FUNC => void!(self.fetch_input(args)),
                PANIC_FUNC => void!(self.panic(args)),
                DEBUG_FUNC => void!(self.debug(args)),
                CCALL_FUNC => some!(self.ccall(args)),
                DCALL_FUNC => some!(self.dcall(args)),
                SCALL_FUNC => some!(self.scall(args)),
                VALUE_FUNC => void!(self.value(args)),
                CREATE_FUNC => some!(self.create(args)),
                SUICIDE_FUNC => void!(self.suicide(args)),
                BLOCKHASH_FUNC => void!(self.blockhash(args)),
                BLOCKNUMBER_FUNC => some!(self.blocknumber()),
                COINBASE_FUNC => void!(self.coinbase(args)),
                DIFFICULTY_FUNC => void!(self.difficulty(args)),
                GASLIMIT_FUNC => void!(self.gaslimit(args)),
                TIMESTAMP_FUNC => some!(self.timestamp()),
                ADDRESS_FUNC => void!(self.address(args)),
                SENDER_FUNC => void!(self.sender(args)),
                ORIGIN_FUNC => void!(self.origin(args)),
                ELOG_FUNC => void!(self.elog(args)),
                CREATE2_FUNC => some!(self.create2(args)),
                GASLEFT_FUNC => some!(self.gasleft()),
                _ => panic!("env module doesn't provide function at index {}", index),
            }
        }
    }
}