Evm gas estimation

runtime/near-evm-runner/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "near-evm-runner"
-version = "0.1.0"
+version = "2.2.0"
 authors = ["Near Inc <hello@nearprotocol.com>"]
 edition = "2018"
 license = "Apache-2.0"

runtime/near-evm-runner/src/builtins.rs

@@ -6,6 +6,7 @@ use std::{
 
 use byteorder::{BigEndian, ByteOrder, LittleEndian, ReadBytesExt};
 use ethereum_types::{Address, H256, U256};
+use near_runtime_fees::EvmCostConfig;
 use num_bigint::BigUint;
 use num_traits::{FromPrimitive, One, ToPrimitive, Zero};
 use parity_bytes::BytesRef;
@@ -45,13 +46,23 @@ pub fn precompile(id: u64) -> Result<Box<dyn Impl>, String> {
     })
 }
 
-pub fn process_precompile(addr: &Address, input: &[u8]) -> MessageCallResult {
+pub fn process_precompile(
+    addr: &Address,
+    input: &[u8],
+    gas: &U256,
+    evm_gas_config: &EvmCostConfig,
+) -> MessageCallResult {
     let f = match precompile(addr.to_low_u64_be()) {
         Ok(f) => f,
         Err(_) => return MessageCallResult::Failed,
     };
     let mut bytes = vec![];
     let mut output = parity_bytes::BytesRef::Flexible(&mut bytes);
+    let cost = f.gas(input, evm_gas_config);
+
+    if cost > *gas {
+        return MessageCallResult::Failed;
+    }
 
     // mutates bytes
     match f.execute(input, &mut output) {
@@ -60,8 +71,7 @@ pub fn process_precompile(addr: &Address, input: &[u8]) -> MessageCallResult {
     };
     let size = bytes.len();
 
-    // TODO: add gas usage here.
-    MessageCallResult::Success(1_000_000_000.into(), ReturnData::new(bytes, 0, size))
+    MessageCallResult::Success(*gas - cost, ReturnData::new(bytes, 0, size))
 }
 
 /** the following is copied from ethcore/src/builtin.rs **/
@@ -128,13 +138,19 @@ pub struct Blake2FImpl;
 pub trait Impl: Send + Sync {
     /// execute this built-in on the given input, writing to the given output.
     fn execute(&self, input: &[u8], output: &mut BytesRef) -> Result<(), Error>;
+    fn gas(&self, _input: &[u8], _evm_gas_config: &EvmCostConfig) -> U256 {
+        0.into()
+    }
 }
 
 impl Impl for Identity {
     fn execute(&self, input: &[u8], output: &mut BytesRef) -> Result<(), Error> {
         output.write(0, input);
         Ok(())
     }
+    fn gas(&self, _input: &[u8], evm_gas_config: &EvmCostConfig) -> U256 {
+        evm_gas_config.identity_cost.into()
+    }
 }
 
 impl Impl for EcRecover {
@@ -174,6 +190,10 @@ impl Impl for EcRecover {
 
         Ok(())
     }
+
+    fn gas(&self, _input: &[u8], evm_gas_config: &EvmCostConfig) -> U256 {
+        evm_gas_config.ecrecover_cost.into()
+    }
 }
 
 impl Impl for Sha256 {
@@ -183,6 +203,10 @@ impl Impl for Sha256 {
         output.write(0, &*d);
         Ok(())
     }
+
+    fn gas(&self, _input: &[u8], evm_gas_config: &EvmCostConfig) -> U256 {
+        evm_gas_config.sha256_cost.into()
+    }
 }
 
 impl Impl for Ripemd160 {
@@ -192,6 +216,10 @@ impl Impl for Ripemd160 {
         output.write(12, &hash);
         Ok(())
     }
+
+    fn gas(&self, _input: &[u8], evm_gas_config: &EvmCostConfig) -> U256 {
+        evm_gas_config.ripemd160_cost.into()
+    }
 }
 
 // calculate modexp: left-to-right binary exponentiation to keep multiplicands lower
@@ -300,6 +328,10 @@ impl Impl for ModexpImpl {
 
         Ok(())
     }
+
+    fn gas(&self, _input: &[u8], evm_gas_config: &EvmCostConfig) -> U256 {
+        evm_gas_config.modexp_cost.into()
+    }
 }
 
 fn read_fr(reader: &mut io::Chain<&[u8], io::Repeat>) -> Result<::bn::Fr, Error> {

runtime/near-evm-runner/src/evm_state.rs

@@ -318,6 +318,30 @@ impl EvmState for SubState<'_> {
     }
 }
 
+pub struct EvmGasCounter {
+    pub used_gas: U256,
+    pub max_gas: U256,
+}
+
+impl EvmGasCounter {
+    pub fn new(used_gas: U256, max_gas: U256) -> EvmGasCounter {
+        Self { used_gas, max_gas }
+    }
+
+    pub fn pay_gas(&mut self, amount: U256) {
+        // TODO: return error if gas not sufficient
+        self.used_gas += amount;
+    }
+
+    pub fn set_gas_left(&mut self, left: U256) {
+        self.used_gas = self.max_gas - left;
+    }
+
+    pub fn gas_left(&self) -> U256 {
+        self.max_gas - self.used_gas
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;