WASM runtime update (#6467)
* refactor to new parity-wasm * more errors refactoring * final test * update tests * fix merge bugs
This commit is contained in:
Nikolay Volf
Gav Wood
parent
375668bc40
commit
ee14a3fb31
|
|
@ -7,7 +7,7 @@ dependencies = [
|
|||
"ethcore-logger 1.8.0",
|
||||
"ethcore-util 1.8.0",
|
||||
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"parity-wasm 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"parity-wasm 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"vm 0.1.0",
|
||||
"wasm-utils 0.1.0 (git+https://github.com/paritytech/wasm-utils)",
|
||||
]
|
||||
|
|
@ -959,7 +959,6 @@ dependencies = [
|
|||
"heapsize 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"parity-wasm 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"parking_lot 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"rlp 0.2.0",
|
||||
"rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
|
|
@ -2188,7 +2187,7 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "parity-wasm"
|
||||
version = "0.12.1"
|
||||
version = "0.14.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"byteorder 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
|
|
@ -3278,13 +3277,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
|||
[[package]]
|
||||
name = "wasm-utils"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/paritytech/wasm-utils#9462bcc0680f0ec2c876abdf75bae981dd4344a5"
|
||||
source = "git+https://github.com/paritytech/wasm-utils#95f9f04d1036c39de5af1c811c6e5dc488fb73d9"
|
||||
dependencies = [
|
||||
"clap 2.24.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"env_logger 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"parity-wasm 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"parity-wasm 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -3500,7 +3500,7 @@ dependencies = [
|
|||
"checksum parity-dapps-glue 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e1d06f6ee0fda786df3784a96ee3f0629f529b91cbfb7d142f6410e6bcd1ce2c"
|
||||
"checksum parity-tokio-ipc 0.1.5 (git+https://github.com/nikvolf/parity-tokio-ipc)" = "<none>"
|
||||
"checksum parity-ui-precompiled 1.4.0 (git+https://github.com/paritytech/js-precompiled.git)" = "<none>"
|
||||
"checksum parity-wasm 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "51104c8b8da5cd0ebe0ab765dfab37bc1927b4a01a3d870b0fe09d9ee65e35ea"
|
||||
"checksum parity-wasm 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)" = "466c01423614bbf89a37b0fc081e1ed3523dfd9064497308ad3f9c7c9f0092bb"
|
||||
"checksum parity-wordlist 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "52142d717754f7ff7ef0fc8da1bdce4f302dd576fb9bf8b727d6a5fdef33348d"
|
||||
"checksum parking_lot 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aebb68eebde2c99f89592d925288600fde220177e46b5c9a91ca218d245aeedf"
|
||||
"checksum parking_lot_core 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fb1b97670a2ffadce7c397fb80a3d687c4f3060140b885621ef1653d0e5d5068"
|
||||
|
|
|
|||
|
|
@ -16,11 +16,10 @@ lazy_static = "0.2"
|
|||
log = "0.3"
|
||||
rlp = { path = "../../util/rlp" }
|
||||
vm = { path = "../vm" }
|
||||
parity-wasm = "0.12"
|
||||
parking_lot = "0.4"
|
||||
ethcore-logger = { path = "../../logger" }
|
||||
wasm-utils = { git = "https://github.com/paritytech/wasm-utils" }
|
||||
hash = { path = "../../util/hash" }
|
||||
parking_lot = "0.4"
|
||||
|
||||
[dev-dependencies]
|
||||
rustc-hex = "1.0"
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@ extern crate ethcore_util as util;
|
|||
extern crate ethcore_bigint as bigint;
|
||||
extern crate ethjson;
|
||||
extern crate rlp;
|
||||
extern crate parity_wasm;
|
||||
extern crate parking_lot;
|
||||
extern crate wasm_utils;
|
||||
extern crate ethcore_logger;
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit 519b0b967cffd7d1236ef21698b1e6e415a048e9
|
||||
Subproject commit 5fd27564f1ab49b25bb419bfc0cc68137e1f12f2
|
||||
|
|
@ -8,7 +8,7 @@ byteorder = "1.0"
|
|||
ethcore-util = { path = "../../util" }
|
||||
ethcore-bigint = { path = "../../util/bigint" }
|
||||
log = "0.3"
|
||||
parity-wasm = "0.12"
|
||||
parity-wasm = "0.14"
|
||||
wasm-utils = { git = "https://github.com/paritytech/wasm-utils" }
|
||||
vm = { path = "../vm" }
|
||||
ethcore-logger = { path = "../../logger" }
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
use parity_wasm::elements::ValueType::*;
|
||||
use parity_wasm::interpreter::{self, UserFunctionDescriptor};
|
||||
use parity_wasm::interpreter::UserFunctionDescriptor::*;
|
||||
use super::runtime::Runtime;
|
||||
use super::runtime::{Runtime, UserTrap};
|
||||
|
||||
pub const SIGNATURES: &'static [UserFunctionDescriptor] = &[
|
||||
Static(
|
||||
|
|
@ -87,6 +87,41 @@ pub const SIGNATURES: &'static [UserFunctionDescriptor] = &[
|
|||
&[I32; 3],
|
||||
Some(I32),
|
||||
),
|
||||
Static(
|
||||
"_panic",
|
||||
&[I32; 2],
|
||||
None,
|
||||
),
|
||||
Static(
|
||||
"_blockhash",
|
||||
&[I32; 3],
|
||||
Some(I32),
|
||||
),
|
||||
Static(
|
||||
"_coinbase",
|
||||
&[I32],
|
||||
None,
|
||||
),
|
||||
Static(
|
||||
"_timestamp",
|
||||
&[],
|
||||
Some(I32),
|
||||
),
|
||||
Static(
|
||||
"_blocknumber",
|
||||
&[],
|
||||
Some(I32),
|
||||
),
|
||||
Static(
|
||||
"_difficulty",
|
||||
&[I32],
|
||||
None,
|
||||
),
|
||||
Static(
|
||||
"_gaslimit",
|
||||
&[I32],
|
||||
None,
|
||||
),
|
||||
|
||||
// TODO: Get rid of it also somehow?
|
||||
Static(
|
||||
|
|
@ -102,9 +137,10 @@ pub const SIGNATURES: &'static [UserFunctionDescriptor] = &[
|
|||
),
|
||||
];
|
||||
|
||||
pub fn native_bindings<'a>(runtime: &'a mut Runtime) -> interpreter::UserFunctions<'a> {
|
||||
interpreter::UserFunctions {
|
||||
executor: runtime,
|
||||
pub fn native_bindings<'a>(runtime: &'a mut Runtime) -> interpreter::UserDefinedElements<'a, UserTrap> {
|
||||
interpreter::UserDefinedElements {
|
||||
executor: Some(runtime),
|
||||
globals: ::std::collections::HashMap::new(),
|
||||
functions: ::std::borrow::Cow::from(SIGNATURES),
|
||||
}
|
||||
}
|
||||
|
|
@ -39,21 +39,41 @@ use parity_wasm::{interpreter, elements};
|
|||
use parity_wasm::interpreter::ModuleInstanceInterface;
|
||||
|
||||
use vm::{GasLeft, ReturnData, ActionParams};
|
||||
use self::runtime::{Runtime, RuntimeContext};
|
||||
use self::runtime::{Runtime, RuntimeContext, UserTrap};
|
||||
|
||||
pub use self::runtime::Error as RuntimeError;
|
||||
pub use self::runtime::InterpreterError;
|
||||
|
||||
const DEFAULT_RESULT_BUFFER: usize = 1024;
|
||||
|
||||
/// Wrapped interpreter error
|
||||
#[derive(Debug)]
|
||||
pub struct Error(InterpreterError);
|
||||
|
||||
impl From<InterpreterError> for Error {
|
||||
fn from(e: InterpreterError) -> Self {
|
||||
Error(e)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Error> for vm::Error {
|
||||
fn from(e: Error) -> Self {
|
||||
vm::Error::Wasm(format!("Wasm runtime error: {:?}", e.0))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<UserTrap> for vm::Error {
|
||||
fn from(e: UserTrap) -> Self { e.into() }
|
||||
}
|
||||
|
||||
/// Wasm interpreter instance
|
||||
pub struct WasmInterpreter {
|
||||
program: interpreter::ProgramInstance,
|
||||
program: runtime::InterpreterProgramInstance,
|
||||
result: Vec<u8>,
|
||||
}
|
||||
|
||||
impl WasmInterpreter {
|
||||
/// New wasm interpreter instance
|
||||
pub fn new() -> Result<WasmInterpreter, RuntimeError> {
|
||||
pub fn new() -> Result<WasmInterpreter, Error> {
|
||||
Ok(WasmInterpreter {
|
||||
program: interpreter::ProgramInstance::new()?,
|
||||
result: Vec::with_capacity(DEFAULT_RESULT_BUFFER),
|
||||
|
|
@ -109,7 +129,7 @@ impl vm::Vm for WasmInterpreter {
|
|||
params.value.value(),
|
||||
params.data.unwrap_or(Vec::with_capacity(0)),
|
||||
)
|
||||
)?;
|
||||
).map_err(|e| Error(e))?;
|
||||
|
||||
{
|
||||
let execution_params = runtime.execution_params()
|
||||
|
|
@ -118,27 +138,30 @@ impl vm::Vm for WasmInterpreter {
|
|||
let module_instance = self.program.add_module("contract", contract_module, Some(&execution_params.externals))
|
||||
.map_err(|err| {
|
||||
trace!(target: "wasm", "Error adding contract module: {:?}", err);
|
||||
vm::Error::from(RuntimeError::Interpreter(err))
|
||||
vm::Error::from(Error(err))
|
||||
})?;
|
||||
|
||||
module_instance.execute_export("_call", execution_params)
|
||||
.map_err(|err| {
|
||||
match module_instance.execute_export("_call", execution_params) {
|
||||
Ok(_) => { },
|
||||
Err(interpreter::Error::User(UserTrap::Suicide)) => { },
|
||||
Err(err) => {
|
||||
trace!(target: "wasm", "Error executing contract: {:?}", err);
|
||||
vm::Error::from(RuntimeError::Interpreter(err))
|
||||
})?;
|
||||
return Err(vm::Error::from(Error(err)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let result = result::WasmResult::new(d_ptr);
|
||||
if result.peek_empty(&*runtime.memory())? {
|
||||
if result.peek_empty(&*runtime.memory()).map_err(|e| Error(e))? {
|
||||
trace!(target: "wasm", "Contract execution result is empty.");
|
||||
Ok(GasLeft::Known(runtime.gas_left()?.into()))
|
||||
} else {
|
||||
self.result.clear();
|
||||
// todo: use memory views to avoid copy
|
||||
self.result.extend(result.pop(&*runtime.memory())?);
|
||||
self.result.extend(result.pop(&*runtime.memory()).map_err(|e| Error(e.into()))?);
|
||||
let len = self.result.len();
|
||||
Ok(GasLeft::NeedsReturn {
|
||||
gas_left: runtime.gas_left()?.into(),
|
||||
gas_left: runtime.gas_left().map_err(|e| Error(e.into()))?.into(),
|
||||
data: ReturnData::new(
|
||||
::std::mem::replace(&mut self.result, Vec::with_capacity(DEFAULT_RESULT_BUFFER)),
|
||||
0,
|
||||
|
|
@ -149,9 +172,3 @@ impl vm::Vm for WasmInterpreter {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<runtime::Error> for vm::Error {
|
||||
fn from(err: runtime::Error) -> vm::Error {
|
||||
vm::Error::Wasm(format!("WASM runtime-error: {:?}", err))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@
|
|||
|
||||
//! Wasm bound-checked ptr
|
||||
|
||||
use parity_wasm::interpreter;
|
||||
use super::runtime::{InterpreterMemoryInstance, InterpreterError, UserTrap};
|
||||
|
||||
/// Bound-checked wrapper for webassembly memory
|
||||
/// Bound-checked wrapper for webassembly memory
|
||||
pub struct WasmPtr(u32);
|
||||
|
||||
/// Error in bound check
|
||||
|
|
@ -28,15 +28,21 @@ pub enum Error {
|
|||
}
|
||||
|
||||
impl From<u32> for WasmPtr {
|
||||
fn from(raw: u32) -> Self {
|
||||
fn from(raw: u32) -> Self {
|
||||
WasmPtr(raw)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Error> for InterpreterError {
|
||||
fn from(_e: Error) -> Self {
|
||||
UserTrap::MemoryAccessViolation.into()
|
||||
}
|
||||
}
|
||||
|
||||
impl WasmPtr {
|
||||
// todo: use memory view when they are on
|
||||
/// Check memory range and return data with given length starting from the current pointer value
|
||||
pub fn slice(&self, len: u32, mem: &interpreter::MemoryInstance) -> Result<Vec<u8>, Error> {
|
||||
pub fn slice(&self, len: u32, mem: &InterpreterMemoryInstance) -> Result<Vec<u8>, Error> {
|
||||
mem.get(self.0, len as usize).map_err(|_| Error::AccessViolation)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -18,10 +18,8 @@
|
|||
|
||||
use byteorder::{LittleEndian, ByteOrder};
|
||||
|
||||
use parity_wasm::interpreter;
|
||||
|
||||
use super::ptr::WasmPtr;
|
||||
use super::runtime::Error as RuntimeError;
|
||||
use super::runtime::{InterpreterError, InterpreterMemoryInstance};
|
||||
|
||||
/// Wrapper for wasm contract call result
|
||||
pub struct WasmResult {
|
||||
|
|
@ -35,13 +33,13 @@ impl WasmResult {
|
|||
}
|
||||
|
||||
/// Check if the result contains any data
|
||||
pub fn peek_empty(&self, mem: &interpreter::MemoryInstance) -> Result<bool, RuntimeError> {
|
||||
pub fn peek_empty(&self, mem: &InterpreterMemoryInstance) -> Result<bool, InterpreterError> {
|
||||
let result_len = LittleEndian::read_u32(&self.ptr.slice(16, mem)?[12..16]);
|
||||
Ok(result_len == 0)
|
||||
}
|
||||
|
||||
/// Consume the result ptr and return the actual data from wasm linear memory
|
||||
pub fn pop(self, mem: &interpreter::MemoryInstance) -> Result<Vec<u8>, RuntimeError> {
|
||||
pub fn pop(self, mem: &InterpreterMemoryInstance) -> Result<Vec<u8>, InterpreterError> {
|
||||
let result_ptr = LittleEndian::read_u32(&self.ptr.slice(16, mem)?[8..12]);
|
||||
let result_len = LittleEndian::read_u32(&self.ptr.slice(16, mem)?[12..16]);
|
||||
trace!(target: "wasm", "contract result: {} bytes at @{}", result_len, result_ptr);
|
||||
|
|
|
|||
|
|
@ -30,31 +30,68 @@ use vm::CallType;
|
|||
use super::ptr::{WasmPtr, Error as PtrError};
|
||||
use super::call_args::CallArgs;
|
||||
|
||||
/// Wasm runtime error
|
||||
#[derive(Debug)]
|
||||
pub enum Error {
|
||||
/// Storage error
|
||||
Storage,
|
||||
/// Allocator error
|
||||
Allocator,
|
||||
/// Invalid gas state during the call
|
||||
InvalidGasState,
|
||||
/// User trap in native code
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum UserTrap {
|
||||
/// Storage read error
|
||||
StorageReadError,
|
||||
/// Storage update error
|
||||
StorageUpdateError,
|
||||
/// Memory access violation
|
||||
AccessViolation,
|
||||
/// Interpreter runtime error
|
||||
Interpreter(interpreter::Error),
|
||||
MemoryAccessViolation,
|
||||
/// Native code resulted in suicide
|
||||
Suicide,
|
||||
/// 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,
|
||||
/// Other error in native code
|
||||
Other,
|
||||
/// Panic with message
|
||||
Panic(String),
|
||||
}
|
||||
|
||||
impl From<interpreter::Error> for Error {
|
||||
fn from(err: interpreter::Error) -> Self {
|
||||
Error::Interpreter(err)
|
||||
impl ::std::fmt::Display for UserTrap {
|
||||
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
|
||||
match *self {
|
||||
UserTrap::StorageReadError => write!(f, "Storage read error"),
|
||||
UserTrap::StorageUpdateError => write!(f, "Storage update error"),
|
||||
UserTrap::MemoryAccessViolation => write!(f, "Memory access violation"),
|
||||
UserTrap::SuicideAbort => write!(f, "Attempt to suicide resulted in an error"),
|
||||
UserTrap::InvalidGasState => write!(f, "Invalid gas state"),
|
||||
UserTrap::BalanceQueryError => write!(f, "Balance query resulted in an error"),
|
||||
UserTrap::Suicide => write!(f, "Suicide result"),
|
||||
UserTrap::Unknown => write!(f, "Unknown runtime function invoked"),
|
||||
UserTrap::AllocationFailed => write!(f, "Memory allocation failed (OOM)"),
|
||||
UserTrap::BadUtf8 => write!(f, "String encoding is bad utf-8 sequence"),
|
||||
UserTrap::GasLimit => write!(f, "Invocation resulted in gas limit violated"),
|
||||
UserTrap::Other => write!(f, "Other unspecified error"),
|
||||
UserTrap::Panic(ref msg) => write!(f, "Panic: {}", msg),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<PtrError> for Error {
|
||||
impl interpreter::UserError for UserTrap { }
|
||||
|
||||
pub type InterpreterError = interpreter::Error<UserTrap>;
|
||||
pub type InterpreterMemoryInstance = interpreter::MemoryInstance<UserTrap>;
|
||||
pub type InterpreterProgramInstance = interpreter::ProgramInstance<UserTrap>;
|
||||
pub type InterpreterCallerContext<'a> = interpreter::CallerContext<'a, UserTrap>;
|
||||
|
||||
impl From<PtrError> for UserTrap {
|
||||
fn from(err: PtrError) -> Self {
|
||||
match err {
|
||||
PtrError::AccessViolation => Error::AccessViolation,
|
||||
PtrError::AccessViolation => UserTrap::MemoryAccessViolation,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -79,20 +116,20 @@ pub struct Runtime<'a, 'b> {
|
|||
gas_limit: u64,
|
||||
dynamic_top: u32,
|
||||
ext: &'a mut vm::Ext,
|
||||
memory: Arc<interpreter::MemoryInstance>,
|
||||
memory: Arc<InterpreterMemoryInstance>,
|
||||
context: RuntimeContext,
|
||||
instance: &'b interpreter::ProgramInstance,
|
||||
instance: &'b InterpreterProgramInstance,
|
||||
}
|
||||
|
||||
impl<'a, 'b> Runtime<'a, 'b> {
|
||||
/// New runtime for wasm contract with specified params
|
||||
pub fn with_params<'c, 'd>(
|
||||
ext: &'c mut vm::Ext,
|
||||
memory: Arc<interpreter::MemoryInstance>,
|
||||
memory: Arc<InterpreterMemoryInstance>,
|
||||
stack_space: u32,
|
||||
gas_limit: u64,
|
||||
context: RuntimeContext,
|
||||
program_instance: &'d interpreter::ProgramInstance,
|
||||
program_instance: &'d InterpreterProgramInstance,
|
||||
) -> Runtime<'c, 'd> {
|
||||
Runtime {
|
||||
gas_counter: 0,
|
||||
|
|
@ -106,30 +143,28 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
|
||||
/// Write to the storage from wasm memory
|
||||
pub fn storage_write(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
pub fn storage_write(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let mut context = context;
|
||||
let val = self.pop_h256(&mut context)?;
|
||||
let key = self.pop_h256(&mut context)?;
|
||||
trace!(target: "wasm", "storage_write: value {} at @{}", &val, &key);
|
||||
|
||||
self.ext.set_storage(key, val)
|
||||
.map_err(|_| interpreter::Error::Trap("Storage update error".to_owned()))?;
|
||||
self.ext.set_storage(key, val).map_err(|_| UserTrap::StorageUpdateError)?;
|
||||
|
||||
Ok(Some(0i32.into()))
|
||||
}
|
||||
|
||||
/// Read from the storage to wasm memory
|
||||
pub fn storage_read(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
pub fn storage_read(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let mut context = context;
|
||||
let val_ptr = context.value_stack.pop_as::<i32>()?;
|
||||
let key = self.pop_h256(&mut context)?;
|
||||
|
||||
let val = self.ext.storage_at(&key)
|
||||
.map_err(|_| interpreter::Error::Trap("Storage read error".to_owned()))?;
|
||||
let val = self.ext.storage_at(&key).map_err(|_| UserTrap::StorageReadError)?;
|
||||
|
||||
self.memory.set(val_ptr as u32, &*val)?;
|
||||
|
||||
|
|
@ -137,21 +172,21 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
|
||||
/// Pass suicide to state runtime
|
||||
pub fn suicide(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
pub fn suicide(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let mut context = context;
|
||||
let refund_address = self.pop_address(&mut context)?;
|
||||
|
||||
self.ext.suicide(&refund_address)
|
||||
.map_err(|_| interpreter::Error::Trap("Suicide error".to_owned()))?;
|
||||
self.ext.suicide(&refund_address).map_err(|_| UserTrap::SuicideAbort)?;
|
||||
|
||||
Ok(None)
|
||||
// We send trap to interpreter so it should abort further execution
|
||||
Err(UserTrap::Suicide.into())
|
||||
}
|
||||
|
||||
/// Invoke create in the state runtime
|
||||
pub fn create(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
pub fn create(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
//
|
||||
// method signature:
|
||||
|
|
@ -172,7 +207,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
let code = self.memory.get(code_ptr, code_len as usize)?;
|
||||
|
||||
let gas_left = self.gas_left()
|
||||
.map_err(|_| interpreter::Error::Trap("Gas state error".to_owned()))?
|
||||
.map_err(|_| UserTrap::InvalidGasState)?
|
||||
.into();
|
||||
|
||||
match self.ext.create(&gas_left, &endowment, &code, vm::CreateContractAddress::FromSenderAndCodeHash) {
|
||||
|
|
@ -189,8 +224,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn call(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
pub fn call(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
//
|
||||
// method signature:
|
||||
|
|
@ -207,8 +242,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
|
||||
|
||||
fn call_code(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
fn call_code(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
//
|
||||
// signature (same as static call):
|
||||
|
|
@ -227,9 +262,9 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
&mut self,
|
||||
use_val: bool,
|
||||
call_type: CallType,
|
||||
context: interpreter::CallerContext,
|
||||
context: InterpreterCallerContext,
|
||||
)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
|
||||
trace!(target: "wasm", "runtime: call code");
|
||||
|
|
@ -255,7 +290,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
|
||||
if let Some(ref val) = val {
|
||||
let address_balance = self.ext.balance(&self.context.address)
|
||||
.map_err(|_| interpreter::Error::Trap("Gas state error".to_owned()))?;
|
||||
.map_err(|_| UserTrap::BalanceQueryError)?;
|
||||
|
||||
if &address_balance < val {
|
||||
trace!(target: "wasm", "runtime: call failed due to balance check");
|
||||
|
|
@ -266,7 +301,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
let mut result = Vec::with_capacity(result_alloc_len as usize);
|
||||
result.resize(result_alloc_len as usize, 0);
|
||||
let gas = self.gas_left()
|
||||
.map_err(|_| interpreter::Error::Trap("Gas state error".to_owned()))?
|
||||
.map_err(|_| UserTrap::InvalidGasState)?
|
||||
.into();
|
||||
// todo: optimize to use memory views once it's in
|
||||
let payload = self.memory.get(input_ptr, input_len as usize)?;
|
||||
|
|
@ -294,8 +329,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn static_call(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
pub fn static_call(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
// signature (same as code call):
|
||||
// fn (
|
||||
|
|
@ -311,8 +346,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
|
||||
|
||||
/// Allocate memory using the wasm stack params
|
||||
pub fn malloc(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
pub fn malloc(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let amount = context.value_stack.pop_as::<i32>()? as u32;
|
||||
let previous_top = self.dynamic_top;
|
||||
|
|
@ -321,21 +356,21 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
|
||||
/// Allocate memory in wasm memory instance
|
||||
pub fn alloc(&mut self, amount: u32) -> Result<u32, Error> {
|
||||
pub fn alloc(&mut self, amount: u32) -> Result<u32, UserTrap> {
|
||||
let previous_top = self.dynamic_top;
|
||||
self.dynamic_top = previous_top + amount;
|
||||
Ok(previous_top.into())
|
||||
}
|
||||
|
||||
/// Report gas cost with the params passed in wasm stack
|
||||
fn gas(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
fn gas(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let amount = context.value_stack.pop_as::<i32>()? as u64;
|
||||
if self.charge_gas(amount) {
|
||||
Ok(None)
|
||||
} else {
|
||||
Err(interpreter::Error::Trap(format!("Gas exceeds limits of {}", self.gas_limit)))
|
||||
Err(UserTrap::GasLimit.into())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -350,50 +385,50 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
}
|
||||
|
||||
fn h256_at(&self, ptr: WasmPtr) -> Result<H256, interpreter::Error> {
|
||||
fn h256_at(&self, ptr: WasmPtr) -> Result<H256, InterpreterError> {
|
||||
Ok(H256::from_slice(&ptr.slice(32, &*self.memory)
|
||||
.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?
|
||||
.map_err(|_| UserTrap::MemoryAccessViolation)?
|
||||
))
|
||||
}
|
||||
|
||||
fn pop_h256(&self, context: &mut interpreter::CallerContext) -> Result<H256, interpreter::Error> {
|
||||
fn pop_h256(&self, context: &mut InterpreterCallerContext) -> Result<H256, InterpreterError> {
|
||||
let ptr = WasmPtr::from_i32(context.value_stack.pop_as::<i32>()?)
|
||||
.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?;
|
||||
.map_err(|_| UserTrap::MemoryAccessViolation)?;
|
||||
self.h256_at(ptr)
|
||||
}
|
||||
|
||||
fn pop_u256(&self, context: &mut interpreter::CallerContext) -> Result<U256, interpreter::Error> {
|
||||
fn pop_u256(&self, context: &mut InterpreterCallerContext) -> Result<U256, InterpreterError> {
|
||||
let ptr = WasmPtr::from_i32(context.value_stack.pop_as::<i32>()?)
|
||||
.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?;
|
||||
.map_err(|_| UserTrap::MemoryAccessViolation)?;
|
||||
self.h256_at(ptr).map(Into::into)
|
||||
}
|
||||
|
||||
fn address_at(&self, ptr: WasmPtr) -> Result<Address, interpreter::Error> {
|
||||
fn address_at(&self, ptr: WasmPtr) -> Result<Address, InterpreterError> {
|
||||
Ok(Address::from_slice(&ptr.slice(20, &*self.memory)
|
||||
.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?
|
||||
.map_err(|_| UserTrap::MemoryAccessViolation)?
|
||||
))
|
||||
}
|
||||
|
||||
fn pop_address(&self, context: &mut interpreter::CallerContext) -> Result<Address, interpreter::Error> {
|
||||
fn pop_address(&self, context: &mut InterpreterCallerContext) -> Result<Address, InterpreterError> {
|
||||
let ptr = WasmPtr::from_i32(context.value_stack.pop_as::<i32>()?)
|
||||
.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?;
|
||||
.map_err(|_| UserTrap::MemoryAccessViolation)?;
|
||||
self.address_at(ptr)
|
||||
}
|
||||
|
||||
fn user_trap(&mut self, _context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
fn unknown_trap(&mut self, _context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, UserTrap>
|
||||
{
|
||||
Err(interpreter::Error::Trap("unknown trap".to_owned()))
|
||||
Err(UserTrap::Unknown)
|
||||
}
|
||||
|
||||
fn user_noop(&mut self,
|
||||
_context: interpreter::CallerContext
|
||||
) -> Result<Option<interpreter::RuntimeValue>, interpreter::Error> {
|
||||
_context: InterpreterCallerContext
|
||||
) -> Result<Option<interpreter::RuntimeValue>, InterpreterError> {
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
/// Write call descriptor to wasm memory
|
||||
pub fn write_descriptor(&mut self, call_args: CallArgs) -> Result<WasmPtr, Error> {
|
||||
pub fn write_descriptor(&mut self, call_args: CallArgs) -> Result<WasmPtr, InterpreterError> {
|
||||
let d_ptr = self.alloc(16)?;
|
||||
|
||||
let args_len = call_args.len();
|
||||
|
|
@ -417,14 +452,14 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
Ok(d_ptr.into())
|
||||
}
|
||||
|
||||
fn debug_log(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
fn debug_log(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let msg_len = context.value_stack.pop_as::<i32>()? as u32;
|
||||
let msg_ptr = context.value_stack.pop_as::<i32>()? as u32;
|
||||
|
||||
let msg = String::from_utf8(self.memory.get(msg_ptr, msg_len as usize)?)
|
||||
.map_err(|_| interpreter::Error::Trap("Debug log utf-8 decoding error".to_owned()))?;
|
||||
.map_err(|_| UserTrap::BadUtf8)?;
|
||||
|
||||
trace!(target: "wasm", "Contract debug message: {}", msg);
|
||||
|
||||
|
|
@ -432,18 +467,18 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
|
||||
/// Query current gas left for execution
|
||||
pub fn gas_left(&self) -> Result<u64, Error> {
|
||||
if self.gas_counter > self.gas_limit { return Err(Error::InvalidGasState); }
|
||||
pub fn gas_left(&self) -> Result<u64, UserTrap> {
|
||||
if self.gas_counter > self.gas_limit { return Err(UserTrap::InvalidGasState); }
|
||||
Ok(self.gas_limit - self.gas_counter)
|
||||
}
|
||||
|
||||
/// Shared memory reference
|
||||
pub fn memory(&self) -> &interpreter::MemoryInstance {
|
||||
pub fn memory(&self) -> &InterpreterMemoryInstance {
|
||||
&*self.memory
|
||||
}
|
||||
|
||||
fn mem_copy(&self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
fn mem_copy(&self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let len = context.value_stack.pop_as::<i32>()? as u32;
|
||||
let dst = context.value_stack.pop_as::<i32>()? as u32;
|
||||
|
|
@ -459,8 +494,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
x >> 24 | x >> 8 & 0xff00 | x << 8 & 0xff0000 | x << 24
|
||||
}
|
||||
|
||||
fn bitswap_i64(&mut self, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
fn bitswap_i64(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let x1 = context.value_stack.pop_as::<i32>()?;
|
||||
let x2 = context.value_stack.pop_as::<i32>()?;
|
||||
|
|
@ -471,13 +506,83 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
self.return_i64(result)
|
||||
}
|
||||
|
||||
fn return_i64(&mut self, val: i64) -> Result<Option<interpreter::RuntimeValue>, interpreter::Error> {
|
||||
fn user_panic(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let msg_len = context.value_stack.pop_as::<i32>()? as u32;
|
||||
let msg_ptr = context.value_stack.pop_as::<i32>()? as u32;
|
||||
|
||||
let msg = String::from_utf8(self.memory.get(msg_ptr, msg_len as usize)?)
|
||||
.map_err(|_| UserTrap::BadUtf8)?;
|
||||
|
||||
trace!(target: "wasm", "Contract custom panic message: {}", msg);
|
||||
|
||||
Err(UserTrap::Panic(msg).into())
|
||||
}
|
||||
|
||||
fn block_hash(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
|
||||
let block_hi = context.value_stack.pop_as::<i32>()? as u32;
|
||||
let block_lo = context.value_stack.pop_as::<i32>()? as u32;
|
||||
|
||||
let block_num = (block_hi as u64) << 32 | block_lo as u64;
|
||||
|
||||
trace!("Requesting block hash for block #{}", block_num);
|
||||
let hash = self.ext.blockhash(&U256::from(block_num));
|
||||
|
||||
self.memory.set(return_ptr, &*hash)?;
|
||||
|
||||
Ok(Some(0i32.into()))
|
||||
}
|
||||
|
||||
fn coinbase(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
|
||||
self.memory.set(return_ptr, &*self.ext.env_info().author)?;
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn timestamp(&mut self, _context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let timestamp = self.ext.env_info().timestamp as i64;
|
||||
self.return_i64(timestamp)
|
||||
}
|
||||
|
||||
fn block_number(&mut self, _context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let block_number: u64 = self.ext.env_info().number.into();
|
||||
self.return_i64(block_number as i64)
|
||||
}
|
||||
|
||||
fn difficulty(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
|
||||
let difficulty: H256 = self.ext.env_info().difficulty.into();
|
||||
self.memory.set(return_ptr, &*difficulty)?;
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn ext_gas_limit(&mut self, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
|
||||
let gas_limit: H256 = self.ext.env_info().gas_limit.into();
|
||||
self.memory.set(return_ptr, &*gas_limit)?;
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn return_i64(&mut self, val: i64) -> Result<Option<interpreter::RuntimeValue>, InterpreterError> {
|
||||
let uval = val as u64;
|
||||
let hi = (uval >> 32) as i32;
|
||||
let lo = (uval << 32 >> 32) as i32;
|
||||
|
||||
let target = self.instance.module("contract")
|
||||
.ok_or(interpreter::Error::Trap("Error locating main execution entry".to_owned()))?;
|
||||
let target = self.instance.module("contract").ok_or(UserTrap::Other)?;
|
||||
target.execute_export(
|
||||
"setTempRet0",
|
||||
self.execution_params().add_argument(
|
||||
|
|
@ -489,7 +594,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
))
|
||||
}
|
||||
|
||||
pub fn execution_params(&mut self) -> interpreter::ExecutionParams {
|
||||
pub fn execution_params(&mut self) -> interpreter::ExecutionParams<UserTrap> {
|
||||
use super::env;
|
||||
|
||||
let env_instance = self.instance.module("env")
|
||||
|
|
@ -505,9 +610,9 @@ impl<'a, 'b> Runtime<'a, 'b> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b> interpreter::UserFunctionExecutor for Runtime<'a, 'b> {
|
||||
fn execute(&mut self, name: &str, context: interpreter::CallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
|
||||
impl<'a, 'b> interpreter::UserFunctionExecutor<UserTrap> for Runtime<'a, 'b> {
|
||||
fn execute(&mut self, name: &str, context: InterpreterCallerContext)
|
||||
-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
|
||||
{
|
||||
match name {
|
||||
"_malloc" => {
|
||||
|
|
@ -551,10 +656,31 @@ impl<'a, 'b> interpreter::UserFunctionExecutor for Runtime<'a, 'b> {
|
|||
"_llvm_bswap_i64" => {
|
||||
self.bitswap_i64(context)
|
||||
},
|
||||
"_panic" => {
|
||||
self.user_panic(context)
|
||||
},
|
||||
"_blockhash" => {
|
||||
self.block_hash(context)
|
||||
},
|
||||
"_coinbase" => {
|
||||
self.coinbase(context)
|
||||
},
|
||||
"_timestamp" => {
|
||||
self.timestamp(context)
|
||||
},
|
||||
"_blocknumber" => {
|
||||
self.block_number(context)
|
||||
},
|
||||
"_difficulty" => {
|
||||
self.difficulty(context)
|
||||
},
|
||||
"_gaslimit" => {
|
||||
self.ext_gas_limit(context)
|
||||
},
|
||||
_ => {
|
||||
trace!(target: "wasm", "Trapped due to unhandled function: '{}'", name);
|
||||
self.user_trap(context)
|
||||
}
|
||||
Ok(self.unknown_trap(context)?)
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::collections::HashMap;
|
||||
use byteorder::{LittleEndian, ByteOrder};
|
||||
use bigint::prelude::U256;
|
||||
use bigint::hash::H256;
|
||||
|
|
@ -87,7 +88,7 @@ fn logger() {
|
|||
};
|
||||
|
||||
println!("ext.store: {:?}", ext.store);
|
||||
assert_eq!(gas_left, U256::from(99327));
|
||||
assert_eq!(gas_left, U256::from(99529));
|
||||
let address_val: H256 = address.into();
|
||||
assert_eq!(
|
||||
ext.store.get(&"0100000000000000000000000000000000000000000000000000000000000000".parse().unwrap()).expect("storage key to exist"),
|
||||
|
|
@ -138,7 +139,7 @@ fn identity() {
|
|||
}
|
||||
};
|
||||
|
||||
assert_eq!(gas_left, U256::from(99_672));
|
||||
assert_eq!(gas_left, U256::from(99_762));
|
||||
|
||||
assert_eq!(
|
||||
Address::from_slice(&result),
|
||||
|
|
@ -172,7 +173,7 @@ fn dispersion() {
|
|||
}
|
||||
};
|
||||
|
||||
assert_eq!(gas_left, U256::from(99_270));
|
||||
assert_eq!(gas_left, U256::from(99_360));
|
||||
|
||||
assert_eq!(
|
||||
result,
|
||||
|
|
@ -201,7 +202,7 @@ fn suicide_not() {
|
|||
}
|
||||
};
|
||||
|
||||
assert_eq!(gas_left, U256::from(99_578));
|
||||
assert_eq!(gas_left, U256::from(99_668));
|
||||
|
||||
assert_eq!(
|
||||
result,
|
||||
|
|
@ -235,7 +236,7 @@ fn suicide() {
|
|||
}
|
||||
};
|
||||
|
||||
assert_eq!(gas_left, U256::from(99_621));
|
||||
assert_eq!(gas_left, U256::from(99_699));
|
||||
assert!(ext.suicides.contains(&refund));
|
||||
}
|
||||
|
||||
|
|
@ -266,7 +267,7 @@ fn create() {
|
|||
assert!(ext.calls.contains(
|
||||
&FakeCall {
|
||||
call_type: FakeCallType::Create,
|
||||
gas: U256::from(99_674),
|
||||
gas: U256::from(99_734),
|
||||
sender_address: None,
|
||||
receive_address: None,
|
||||
value: Some(1_000_000_000.into()),
|
||||
|
|
@ -274,7 +275,7 @@ fn create() {
|
|||
code_address: None,
|
||||
}
|
||||
));
|
||||
assert_eq!(gas_left, U256::from(99_596));
|
||||
assert_eq!(gas_left, U256::from(99_686));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -308,7 +309,7 @@ fn call_code() {
|
|||
assert!(ext.calls.contains(
|
||||
&FakeCall {
|
||||
call_type: FakeCallType::Call,
|
||||
gas: U256::from(99_069),
|
||||
gas: U256::from(99_129),
|
||||
sender_address: Some(sender),
|
||||
receive_address: Some(receiver),
|
||||
value: None,
|
||||
|
|
@ -316,7 +317,7 @@ fn call_code() {
|
|||
code_address: Some("0d13710000000000000000000000000000000000".parse().unwrap()),
|
||||
}
|
||||
));
|
||||
assert_eq!(gas_left, U256::from(94144));
|
||||
assert_eq!(gas_left, U256::from(94262));
|
||||
|
||||
// siphash result
|
||||
let res = LittleEndian::read_u32(&result[..]);
|
||||
|
|
@ -353,7 +354,7 @@ fn call_static() {
|
|||
assert!(ext.calls.contains(
|
||||
&FakeCall {
|
||||
call_type: FakeCallType::Call,
|
||||
gas: U256::from(99_069),
|
||||
gas: U256::from(99_129),
|
||||
sender_address: Some(sender),
|
||||
receive_address: Some(receiver),
|
||||
value: None,
|
||||
|
|
@ -361,7 +362,7 @@ fn call_static() {
|
|||
code_address: Some("13077bfb00000000000000000000000000000000".parse().unwrap()),
|
||||
}
|
||||
));
|
||||
assert_eq!(gas_left, U256::from(94144));
|
||||
assert_eq!(gas_left, U256::from(94262));
|
||||
|
||||
// siphash result
|
||||
let res = LittleEndian::read_u32(&result[..]);
|
||||
|
|
@ -387,7 +388,7 @@ fn realloc() {
|
|||
GasLeft::NeedsReturn { gas_left: gas, data: result, apply_state: _apply } => (gas, result.to_vec()),
|
||||
}
|
||||
};
|
||||
assert_eq!(gas_left, U256::from(99432));
|
||||
assert_eq!(gas_left, U256::from(99522));
|
||||
assert_eq!(result, vec![0u8; 2]);
|
||||
}
|
||||
|
||||
|
|
@ -413,12 +414,15 @@ fn storage_read() {
|
|||
}
|
||||
};
|
||||
|
||||
assert_eq!(gas_left, U256::from(99682));
|
||||
assert_eq!(gas_left, U256::from(99800));
|
||||
assert_eq!(Address::from(&result[12..32]), address);
|
||||
}
|
||||
|
||||
macro_rules! reqrep_test {
|
||||
($name: expr, $input: expr) => {
|
||||
reqrep_test!($name, $input, vm::EnvInfo::default(), HashMap::new())
|
||||
};
|
||||
($name: expr, $input: expr, $info: expr, $block_hashes: expr) => {
|
||||
{
|
||||
::ethcore_logger::init_log();
|
||||
let code = load_sample!($name);
|
||||
|
|
@ -428,9 +432,13 @@ macro_rules! reqrep_test {
|
|||
params.code = Some(Arc::new(code));
|
||||
params.data = Some($input);
|
||||
|
||||
let mut fake_ext = FakeExt::new();
|
||||
fake_ext.info = $info;
|
||||
fake_ext.blockhashes = $block_hashes;
|
||||
|
||||
let (gas_left, result) = {
|
||||
let mut interpreter = wasm_interpreter();
|
||||
let result = interpreter.exec(params, &mut FakeExt::new()).expect("Interpreter to execute without any errors");
|
||||
let result = interpreter.exec(params, &mut fake_ext).expect("Interpreter to execute without any errors");
|
||||
match result {
|
||||
GasLeft::Known(_) => { panic!("Test is expected to return payload to check"); },
|
||||
GasLeft::NeedsReturn { gas_left: gas, data: result, apply_state: _apply } => (gas, result.to_vec()),
|
||||
|
|
@ -439,7 +447,7 @@ macro_rules! reqrep_test {
|
|||
|
||||
(gas_left, result)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// math_* tests check the ability of wasm contract to perform big integer operations
|
||||
|
|
@ -464,7 +472,7 @@ fn math_add() {
|
|||
}
|
||||
);
|
||||
|
||||
assert_eq!(gas_left, U256::from(98087));
|
||||
assert_eq!(gas_left, U256::from(98177));
|
||||
assert_eq!(
|
||||
U256::from_dec_str("1888888888888888888888888888887").unwrap(),
|
||||
(&result[..]).into()
|
||||
|
|
@ -486,7 +494,7 @@ fn math_mul() {
|
|||
}
|
||||
);
|
||||
|
||||
assert_eq!(gas_left, U256::from(97236));
|
||||
assert_eq!(gas_left, U256::from(97326));
|
||||
assert_eq!(
|
||||
U256::from_dec_str("888888888888888888888888888887111111111111111111111111111112").unwrap(),
|
||||
(&result[..]).into()
|
||||
|
|
@ -508,7 +516,7 @@ fn math_sub() {
|
|||
}
|
||||
);
|
||||
|
||||
assert_eq!(gas_left, U256::from(98131));
|
||||
assert_eq!(gas_left, U256::from(98221));
|
||||
assert_eq!(
|
||||
U256::from_dec_str("111111111111111111111111111111").unwrap(),
|
||||
(&result[..]).into()
|
||||
|
|
@ -529,9 +537,97 @@ fn math_div() {
|
|||
}
|
||||
);
|
||||
|
||||
assert_eq!(gas_left, U256::from(91420));
|
||||
assert_eq!(gas_left, U256::from(91510));
|
||||
assert_eq!(
|
||||
U256::from_dec_str("1125000").unwrap(),
|
||||
(&result[..]).into()
|
||||
);
|
||||
}
|
||||
|
||||
// This test checks the ability of wasm contract to invoke
|
||||
// varios blockchain runtime methods
|
||||
#[test]
|
||||
fn externs() {
|
||||
let (gas_left, result) = reqrep_test!(
|
||||
"externs.wasm",
|
||||
Vec::new(),
|
||||
vm::EnvInfo {
|
||||
number: 0x9999999999u64.into(),
|
||||
author: "efefefefefefefefefefefefefefefefefefefef".parse().unwrap(),
|
||||
timestamp: 0x8888888888u64.into(),
|
||||
difficulty: H256::from("0f1f2f3f4f5f6f7f8f9fafbfcfdfefff0d1d2d3d4d5d6d7d8d9dadbdcdddedfd").into(),
|
||||
gas_limit: 0x777777777777u64.into(),
|
||||
last_hashes: Default::default(),
|
||||
gas_used: 0.into(),
|
||||
},
|
||||
{
|
||||
let mut hashes = HashMap::new();
|
||||
hashes.insert(
|
||||
U256::from(0),
|
||||
H256::from("9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d")
|
||||
);
|
||||
hashes.insert(
|
||||
U256::from(1),
|
||||
H256::from("7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b")
|
||||
);
|
||||
hashes
|
||||
}
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
&result[0..64].to_vec(),
|
||||
&vec![
|
||||
0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
|
||||
0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b,0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b,
|
||||
],
|
||||
"Block hashes requested and returned do not match"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
&result[64..84].to_vec(),
|
||||
&vec![
|
||||
0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
|
||||
],
|
||||
"Coinbase requested and returned does not match"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
&result[84..92].to_vec(),
|
||||
&vec![
|
||||
0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00
|
||||
],
|
||||
"Timestamp requested and returned does not match"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
&result[92..100].to_vec(),
|
||||
&vec![
|
||||
0x99, 0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00
|
||||
],
|
||||
"Block number requested and returned does not match"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
&result[100..132].to_vec(),
|
||||
&vec![
|
||||
0x0f, 0x1f, 0x2f, 0x3f, 0x4f, 0x5f, 0x6f, 0x7f,
|
||||
0x8f, 0x9f, 0xaf, 0xbf, 0xcf, 0xdf, 0xef, 0xff,
|
||||
0x0d, 0x1d, 0x2d, 0x3d, 0x4d, 0x5d, 0x6d, 0x7d,
|
||||
0x8d, 0x9d, 0xad, 0xbd, 0xcd, 0xdd, 0xed, 0xfd,
|
||||
],
|
||||
"Difficulty requested and returned does not match"
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
&result[132..164].to_vec(),
|
||||
&vec![
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
|
||||
],
|
||||
"Gas limit requested and returned does not match"
|
||||
);
|
||||
|
||||
assert_eq!(gas_left, U256::from(97588));
|
||||
}
|
||||
Loading…
Reference in New Issue