Merge pull request #12 from bandprotocol/refactor

Refactor

Author: colmazia

packages/vm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "owasm-vm"
-version = "0.1.12"
+version = "0.2.0"
 authors = ["Band Protocol <[email protected]>"]
 edition = "2021"
 license = "Apache-2.0"
@@ -11,11 +11,10 @@ readme = "README.md"
 [dependencies]
 assert_matches = "1.3.0"
 hex = "0.4"
-parity-wasm = "0.41"
-pwasm-utils = "0.12"
+wasm-instrument = "0.2.0"
 wasmer = { version = "2.3.0", default-features = false, features = ["singlepass", "compiler", "universal"] }
 wasmer-middlewares = "2.3.0"
 # owasm-crypto = { path = "../crypto", version = "0.1.13" }
 tempfile = "3.1.0"
 clru = "0.2.0"
-cosmwasm-vm = "0.13.2"
+sha2 = "0.9.1"

packages/vm/src/cache.rs

@@ -1,7 +1,7 @@
+use crate::checksum::Checksum;
 use crate::error::Error;
 
 use clru::CLruCache;
-use cosmwasm_vm::Checksum;
 use wasmer::{Instance, Module, Store};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]

packages/vm/src/calls.rs

@@ -0,0 +1,217 @@
+use crate::cache::Cache;
+use crate::error::Error;
+use crate::imports::create_import_object;
+use crate::store::make_store;
+use crate::vm::{Env, Environment};
+
+use std::ptr::NonNull;
+use wasmer_middlewares::metering::{get_remaining_points, MeteringPoints};
+
+pub fn run<E>(
+    cache: &mut Cache,
+    code: &[u8],
+    gas_limit: u64,
+    is_prepare: bool,
+    env: E,
+) -> Result<u64, Error>
+where
+    E: Env + 'static,
+{
+    let owasm_env = Environment::new(env);
+    let store = make_store();
+    let import_object = create_import_object(&store, owasm_env.clone());
+
+    let instance = cache.get_instance(code, &store, &import_object)?;
+    let instance_ptr = NonNull::from(&instance);
+    owasm_env.set_wasmer_instance(Some(instance_ptr));
+    owasm_env.set_gas_left(gas_limit);
+
+    // get function and exec
+    let entry = if is_prepare { "prepare" } else { "execute" };
+    let function = instance
+        .exports
+        .get_function(entry)
+        .unwrap()
+        .native::<(), ()>()
+        .map_err(|_| Error::BadEntrySignatureError)?;
+
+    function.call().map_err(|runtime_err| {
+        if let Ok(err) = runtime_err.downcast::<Error>() {
+            return err.clone();
+        }
+
+        match get_remaining_points(&instance) {
+            MeteringPoints::Remaining(_) => Error::RuntimeError,
+            MeteringPoints::Exhausted => Error::OutOfGasError,
+        }
+    })?;
+
+    match get_remaining_points(&instance) {
+        MeteringPoints::Remaining(count) => Ok(gas_limit.saturating_sub(count)),
+        MeteringPoints::Exhausted => Err(Error::OutOfGasError),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::cache::CacheOptions;
+
+    use super::*;
+    use crate::compile::compile;
+    use std::io::{Read, Write};
+    use std::process::Command;
+    use tempfile::NamedTempFile;
+
+    pub struct MockEnv {}
+
+    impl Env for MockEnv {
+        fn get_span_size(&self) -> i64 {
+            300
+        }
+        fn get_calldata(&self) -> Result<Vec<u8>, Error> {
+            Ok(vec![1])
+        }
+        fn set_return_data(&self, _: &[u8]) -> Result<(), Error> {
+            Ok(())
+        }
+        fn get_ask_count(&self) -> i64 {
+            10
+        }
+        fn get_min_count(&self) -> i64 {
+            8
+        }
+        fn get_prepare_time(&self) -> i64 {
+            100_000
+        }
+        fn get_execute_time(&self) -> Result<i64, Error> {
+            Ok(100_000)
+        }
+        fn get_ans_count(&self) -> Result<i64, Error> {
+            Ok(8)
+        }
+        fn ask_external_data(&self, _: i64, _: i64, _: &[u8]) -> Result<(), Error> {
+            Ok(())
+        }
+        fn get_external_data_status(&self, _: i64, _: i64) -> Result<i64, Error> {
+            Ok(1)
+        }
+        fn get_external_data(&self, _: i64, _: i64) -> Result<Vec<u8>, Error> {
+            Ok(vec![1])
+        }
+    }
+
+    fn wat2wasm(wat: impl AsRef<[u8]>) -> Vec<u8> {
+        let mut input_file = NamedTempFile::new().unwrap();
+        let mut output_file = NamedTempFile::new().unwrap();
+        input_file.write_all(wat.as_ref()).unwrap();
+        Command::new("wat2wasm")
+            .args(&[
+                input_file.path().to_str().unwrap(),
+                "-o",
+                output_file.path().to_str().unwrap(),
+            ])
+            .output()
+            .unwrap();
+        let mut wasm = Vec::new();
+        output_file.read_to_end(&mut wasm).unwrap();
+        wasm
+    }
+
+    #[test]
+    fn test_simple_gas_used() {
+        let wasm = wat2wasm(
+            r#"(module
+            (type (func (param i64 i64 i64 i64) (result)))
+            (func
+              (local $idx i32)
+              (local.set $idx (i32.const 0))
+              (block
+                  (loop
+                    (local.set $idx (local.get $idx) (i32.const 1) (i32.add) )
+                    (br_if 0 (i32.lt_u (local.get $idx) (i32.const 100000)))
+                  )
+                )
+            )
+            (func (;"execute": Resolves with result "beeb";)
+              )
+            (memory 17)
+            (data (i32.const 1048576) "beeb") (;str = "beeb";)
+            (export "prepare" (func 0))
+            (export "execute" (func 1)))
+          "#,
+        );
+        let code = compile(&wasm).unwrap();
+        let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
+        let env = MockEnv {};
+        let gas_used = run(&mut cache, &code, u64::MAX, true, env).unwrap();
+        assert_eq!(gas_used, 2000032500000 as u64);
+    }
+
+    #[test]
+    fn test_ask_count_gas_used() {
+        let wasm = wat2wasm(
+            r#"(module
+                (type (func (param i64 i64 i64 i64) (result)))
+                (import "env" "ask_external_data" (func (type 0)))
+                (func
+                    (local $idx i32)
+
+                    (i64.const 1)
+                    (i64.const 1)
+                    (i64.const 1048576)
+                    (i64.const 4)                  
+                    call 0
+
+                    (local.set $idx (i32.const 0))
+                    (block
+                        (loop
+                            (local.set $idx (local.get $idx) (i32.const 1) (i32.add) )
+                            (br_if 0 (i32.lt_u (local.get $idx) (i32.const 100000)))
+                        )
+                    )
+                )
+                (func (;"execute": Resolves with result "beeb";))
+                (memory (export "memory") 17)
+                (data (i32.const 1048576) "beeb")              
+                (export "prepare" (func 1))
+                (export "execute" (func 2)))
+            "#,
+        );
+
+        let code = compile(&wasm).unwrap();
+        let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
+        let env = MockEnv {};
+        let gas_used = run(&mut cache, &code, u64::MAX, true, env).unwrap();
+        assert_eq!(gas_used, 2000045000000 as u64);
+    }
+
+    #[test]
+    fn test_out_of_gas() {
+        let wasm = wat2wasm(
+            r#"(module
+            (type (func (param i64 i64 i64 i64) (result)))
+            (func
+              (local $idx i32)
+              (local.set $idx (i32.const 0))
+              (block
+                  (loop
+                    (local.set $idx (local.get $idx) (i32.const 1) (i32.add) )
+                    (br_if 0 (i32.lt_u (local.get $idx) (i32.const 100000)))
+                  )
+                )
+            )
+            (func (;"execute": Resolves with result "beeb";)
+              )
+            (memory 17)
+            (data (i32.const 1048576) "beeb") (;str = "beeb";)
+            (export "prepare" (func 0))
+            (export "execute" (func 1)))
+          "#,
+        );
+        let code = compile(&wasm).unwrap();
+        let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
+        let env = MockEnv {};
+        let out_of_gas_err = run(&mut cache, &code, 0, true, env).unwrap_err();
+        assert_eq!(out_of_gas_err, Error::OutOfGasError);
+    }
+}

packages/vm/src/checksum.rs

@@ -0,0 +1,88 @@
+use crate::Error;
+
+use sha2::{Digest, Sha256};
+use std::convert::TryFrom;
+
+/// This is a copy of checksum.rs from https://github.com/CosmWasm/cosmwasm/blob/6082e8a35a193f1365cb3367f77bd87c593a7ae4/packages/vm/src/checksum.rs
+///
+/// A SHA-256 checksum of a Wasm blob, used to identify a Wasm code.
+/// This must remain stable since this checksum is stored in the blockchain state.
+///
+/// This is often referred to as "code ID" in go-cosmwasm, even if code ID
+/// usually refers to an auto-incrementing number.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Checksum([u8; 32]);
+
+impl Checksum {
+    pub fn generate(wasm: &[u8]) -> Self {
+        Checksum(Sha256::digest(wasm).into())
+    }
+
+    /// Creates a lowercase hex encoded copy of this checksum
+    pub fn to_hex(&self) -> String {
+        hex::encode(self.0)
+    }
+}
+
+impl From<[u8; 32]> for Checksum {
+    fn from(data: [u8; 32]) -> Self {
+        Checksum(data)
+    }
+}
+
+impl TryFrom<&[u8]> for Checksum {
+    type Error = Error;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        if value.len() != 32 {
+            return Err(Error::ChecksumLengthNotMatch);
+        }
+        let mut data = [0u8; 32];
+        data.copy_from_slice(value);
+        Ok(Checksum(data))
+    }
+}
+
+impl Into<Vec<u8>> for Checksum {
+    fn into(self) -> Vec<u8> {
+        // Rust 1.43+ also supports self.0.into()
+        self.0.to_vec()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn generate_works() {
+        let wasm = vec![0x68, 0x69, 0x6a];
+        let checksum = Checksum::generate(&wasm);
+
+        // echo -n "hij" | sha256sum
+        let expected = [
+            0x72, 0x2c, 0x8c, 0x99, 0x3f, 0xd7, 0x5a, 0x76, 0x27, 0xd6, 0x9e, 0xd9, 0x41, 0x34,
+            0x4f, 0xe2, 0xa1, 0x42, 0x3a, 0x3e, 0x75, 0xef, 0xd3, 0xe6, 0x77, 0x8a, 0x14, 0x28,
+            0x84, 0x22, 0x71, 0x04,
+        ];
+        assert_eq!(checksum.0, expected);
+    }
+
+    #[test]
+    fn to_hex_works() {
+        let wasm = vec![0x68, 0x69, 0x6a];
+        let checksum = Checksum::generate(&wasm);
+        // echo -n "hij" | sha256sum
+        assert_eq!(
+            checksum.to_hex(),
+            "722c8c993fd75a7627d69ed941344fe2a1423a3e75efd3e6778a142884227104"
+        );
+    }
+
+    #[test]
+    fn into_vec_works() {
+        let checksum = Checksum::generate(&vec![12u8; 17]);
+        let as_vec: Vec<u8> = checksum.into();
+        assert_eq!(as_vec, checksum.0);
+    }
+}