remove vrf & change gas to u64

Author: colmazia

packages/vm/Cargo.toml

@@ -2,7 +2,7 @@
 name = "owasm-vm"
 version = "0.1.12"
 authors = ["Band Protocol <[email protected]>"]
-edition = "2018"
+edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/bandprotocol/owasm/tree/master/packages/vm"
 description = "Oracle script VM runtime"
@@ -15,7 +15,7 @@ parity-wasm = "0.41"
 pwasm-utils = "0.12"
 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" }
+# owasm-crypto = { path = "../crypto", version = "0.1.13" }
 tempfile = "3.1.0"
 clru = "0.2.0"
 cosmwasm-vm = "0.13.2"

packages/vm/src/lib.rs

@@ -20,7 +20,7 @@ use wasmer::Singlepass;
 use wasmer::{imports, wasmparser, wasmparser::Operator, CompilerConfig, Function, Store};
 use wasmer_middlewares::Metering;
 
-use owasm_crypto::ecvrf;
+// use owasm_crypto::ecvrf;
 
 // inspired by https://github.com/CosmWasm/cosmwasm/issues/81
 // 512 pages = 32mb
@@ -156,11 +156,11 @@ fn require_mem_range(max_range: usize, require_range: usize) -> Result<(), Error
     Ok(())
 }
 
-fn get_from_mem<E: vm::Env>(env: &Environment<E>, ptr: i64, len: i64) -> Result<Vec<u8>, Error> {
-    let memory = env.memory()?;
-    require_mem_range(memory.size().bytes().0, (ptr + len) as usize)?;
-    Ok(memory.view()[ptr as usize..(ptr + len) as usize].iter().map(|cell| cell.get()).collect())
-}
+// fn get_from_mem<E: vm::Env>(env: &Environment<E>, ptr: i64, len: i64) -> Result<Vec<u8>, Error> {
+//     let memory = env.memory()?;
+//     require_mem_range(memory.size().bytes().0, (ptr + len) as usize)?;
+//     Ok(memory.view()[ptr as usize..(ptr + len) as usize].iter().map(|cell| cell.get()).collect())
+// }
 
 fn cost(_operator: &Operator) -> u64 {
     // A flat fee for each operation
@@ -170,18 +170,17 @@ fn cost(_operator: &Operator) -> u64 {
 pub fn run<E>(
     cache: &mut Cache,
     code: &[u8],
-    gas: u32,
+    gas: u64,
     is_prepare: bool,
     env: E,
-) -> Result<u32, Error>
+) -> Result<u64, Error>
 where
     E: vm::Env + 'static,
 {
     let owasm_env = Environment::new(env, gas);
 
     let mut compiler = Singlepass::new();
-
-    let metering = Arc::new(Metering::new(4294967290, cost));
+    let metering = Arc::new(Metering::new(0, cost));
     compiler.push_middleware(metering);
     let engine = Universal::new(compiler).engine();
     let store = Store::new(&engine);
@@ -270,8 +269,8 @@ where
                     }
 
                     // consume gas equal size of span when write calldata for raw request
-                    vm.consume_gas(span_size  as u32)?;
-                    env.decrease_gas_left(span_size as u32)?;
+                    // vm.consume_gas(span_size  as u32)?;
+                    // env.decrease_gas_left(span_size as u32)?;
 
                     let memory = env.memory()?;
                     require_mem_range(memory.size().bytes().0, (ptr + span_size) as usize)?;
@@ -304,24 +303,32 @@ where
                     Ok(data.len() as i64)
                 })
             }),
-            "ecvrf_verify" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, y_ptr: i64, y_len: i64, pi_ptr: i64, pi_len: i64, alpha_ptr: i64, alpha_len: i64| {
-                env.with_mut_vm(|vm| -> Result<u32, Error>{
-                    // consume gas relatively to the function running time (~12ms)
-                    vm.consume_gas(500000)?;
-                    env.decrease_gas_left(500000)?;
-
-                    let y: Vec<u8> = get_from_mem(env, y_ptr, y_len)?;
-                    let pi: Vec<u8>= get_from_mem(env, pi_ptr, pi_len)?;
-                    let alpha: Vec<u8> = get_from_mem(env, alpha_ptr, alpha_len)?;
-                    Ok(ecvrf::ecvrf_verify(&y, &pi, &alpha) as u32)
-                })
-            }),
+            // "ecvrf_verify" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, y_ptr: i64, y_len: i64, pi_ptr: i64, pi_len: i64, alpha_ptr: i64, alpha_len: i64| {
+            //     env.with_mut_vm(|vm| -> Result<u32, Error>{
+            //         // consume gas relatively to the function running time (~12ms)
+            //         vm.consume_gas(500000)?;
+            //         env.decrease_gas_left(500000)?;
+
+            //         let y: Vec<u8> = get_from_mem(env, y_ptr, y_len)?;
+            //         let pi: Vec<u8>= get_from_mem(env, pi_ptr, pi_len)?;
+            //         let alpha: Vec<u8> = get_from_mem(env, alpha_ptr, alpha_len)?;
+            //         Ok(ecvrf::ecvrf_verify(&y, &pi, &alpha) as u32)
+            //     })
+            // }),
         },
     };
 
     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);
+
+    match get_remaining_points(&instance) {
+        MeteringPoints::Remaining(count) => {
+            println!("gas {:?}, count {:?}, gas_used {:?}", gas, count, gas.saturating_sub(count));
+        }
+        MeteringPoints::Exhausted => {}
+    }
 
     // get function and exec
     let entry = if is_prepare { "prepare" } else { "execute" };
@@ -344,10 +351,12 @@ where
     })?;
 
     match get_remaining_points(&instance) {
-        MeteringPoints::Remaining(count) => return Ok(gas - (count as u32)),
-        MeteringPoints::Exhausted => return Ok(gas),
-    };
-    // Ok(owasm_env.with_vm(|vm| vm.gas_used))
+        MeteringPoints::Remaining(count) => {
+            println!("gas {:?}, count {:?}, gas_used {:?}", gas, count, gas.saturating_sub(count));
+            Ok(gas.saturating_sub(count))
+        }
+        MeteringPoints::Exhausted => Err(Error::OutOfGasError),
+    }
 }
 
 #[cfg(test)]
@@ -536,7 +545,7 @@ mod test {
         let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
         let env = MockEnv {};
         let gas_used = run(&mut cache, &code, 4294967290, true, env).unwrap();
-        assert_eq!(gas_used, 1000015 as u32);
+        assert_eq!(gas_used, 1000015 as u64);
     }
 
     // #[test]

packages/vm/src/vm.rs

@@ -38,22 +38,22 @@ where
     E: Env,
 {
     pub env: E,         // The execution environment.
-    pub gas_limit: u32, // Amount of gas allowed for total execution.
-    pub gas_used: u32,  // Amount of gas used in this execution.
+    pub gas_limit: u64, // Amount of gas allowed for total execution.
+    pub gas_used: u64,  // Amount of gas used in this execution.
 }
 
 impl<E> VMLogic<E>
 where
     E: Env,
 {
     /// Creates a new `VMLogic` instance.
-    pub fn new(env: E, gas: u32) -> Self {
+    pub fn new(env: E, gas: u64) -> Self {
         Self { env: env, gas_limit: gas, gas_used: 0 }
     }
 
     /// Consumes the given amount of gas. Return `OutOfGasError` error if run out of gas.
     pub fn consume_gas(&mut self, gas: u32) -> Result<(), Error> {
-        self.gas_used = self.gas_used.saturating_add(gas);
+        self.gas_used = self.gas_used.saturating_add(gas as u64);
         if self.out_of_gas() {
             Err(Error::OutOfGasError)
         } else {
@@ -98,7 +98,7 @@ impl<E> Environment<E>
 where
     E: Env + 'static,
 {
-    pub fn new(e: E, gas: u32) -> Self {
+    pub fn new(e: E, gas: u64) -> Self {
         Self {
             vm: Arc::new(Mutex::new(VMLogic::<E>::new(e, gas))),
             data: Arc::new(RwLock::new(ContextData::new())),