wip-bump-revm

Author: abukosek

Cargo.lock

@@ -27,7 +27,7 @@ rand_core = { version = "0.6.4", default-features = false }
 # Ethereum.
 ethabi = { version = "18.0.0", default-features = false, features = ["std"] }
 ethereum = "0.15"
-revm = { git = "https://github.com/bluealloy/revm", tag = "v56", default-features = false, features = ["std", "serde", "optional_eip3607"] }
+revm = { git = "https://github.com/bluealloy/revm", tag = "v66", default-features = false, features = ["std", "serde", "optional_eip3607"] }
 fixed-hash = "0.8.0"
 primitive-types = { version = "0.12", default-features = false, features = ["rlp", "num-traits"] }
 rlp = "0.5.2"

runtime-sdk/modules/evm-new/Cargo.toml

@@ -1,8 +1,10 @@
 use revm::{
-    primitives::{Account, AccountInfo, Address, Bytecode, B256, KECCAK_EMPTY, U256},
+    database::DBErrorMarker,
+    primitives::{Address, B256, KECCAK_EMPTY, U256},
+    state::{Account, AccountInfo, Bytecode},
     Database, DatabaseCommit,
 };
-use std::{collections::HashMap, vec::Vec};
+use std::{collections::HashMap, error::Error, fmt, vec::Vec};
 
 use std::marker::PhantomData;
 
@@ -27,9 +29,27 @@ impl<'ctx, C: Context, Cfg: Config> OasisDB<'ctx, C, Cfg> {
     }
 }
 
+#[derive(Debug)]
+pub struct DBError(pub String);
+
+impl DBErrorMarker for DBError {}
+impl Error for DBError {}
+
+impl fmt::Display for DBError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<String> for DBError {
+    fn from(s: String) -> Self {
+        Self(s)
+    }
+}
+
 // Implement read-only parts of the database.
 impl<'ctx, C: Context, Cfg: Config> Database for OasisDB<'ctx, C, Cfg> {
-    type Error = String;
+    type Error = DBError;
 
     /// Get basic account information.
     fn basic(&mut self, address: Address) -> Result<Option<AccountInfo>, Self::Error> {
@@ -79,7 +99,7 @@ impl<'ctx, C: Context, Cfg: Config> Database for OasisDB<'ctx, C, Cfg> {
     /// Get account code by its hash (unimplemented).
     fn code_by_hash(&mut self, _code_hash: B256) -> Result<Bytecode, Self::Error> {
         println!("###### code_by_hash called ######");
-        Err("getting code by hash is not supported".to_string())
+        Err("getting code by hash is not supported".to_string().into())
     }
 
     /// Get storage value of address at index.

runtime-sdk/modules/evm-new/src/db.rs

@@ -10,13 +10,13 @@ mod signed_call;
 pub mod state;
 pub mod types;
 
-use std::sync::Arc;
-
 use base64::prelude::*;
 use revm::{
+    context::TxEnv,
+    context_interface::result::{ExecutionResult, Output},
     precompile::PrecompileWithAddress,
-    primitives::{Bytes, ExecutionResult, Output, SpecId, TxEnv, TxKind},
-    Evm,
+    primitives::{hardfork::SpecId, Bytes, TxKind},
+    Context as EvmContext, ExecuteCommitEvm, ExecuteEvm, MainBuilder, MainContext,
 };
 
 use oasis_runtime_sdk::{
@@ -394,46 +394,43 @@ impl<Cfg: Config> Module<Cfg> {
 
         // Prepare the environment.
         let db = db::OasisDB::<'_, C, Cfg>::new(ctx);
-        let mut evm = Evm::builder()
+        let mut evm = EvmContext::mainnet()
             .with_db(db)
-            .with_spec_id(SpecId::SHANGHAI)
-            .modify_cfg_env(|cfg| {
+            .modify_cfg_chained(|cfg| {
+                cfg.spec = SpecId::SHANGHAI;
                 cfg.disable_eip3607 = true;
             })
-            .append_handler_register(|handler| {
+            // TODO: Port precompiles to the new API.
+            /*.append_handler_register(|handler| {
                 // Load standard precompiles.
                 //
                 // For Shanghai spec these include the following: ecrecover,
                 // sha256, ripemd160, identity, bn128::{add,mul,pair}, blake2,
                 // modexp.
                 let precompiles = handler.pre_execution.load_precompiles();
-
                 handler.pre_execution.load_precompiles = Arc::new(move || {
                     // Start with standard precompiles.
                     let mut precompiles = precompiles.clone();
-
                     // Extend with Oasis-specific precompiles.
                     precompiles.extend(precompile::new());
-
                     // Extend with module-specific precompiles (if any).
                     if let Some(additional_precompiles) = Cfg::additional_precompiles() {
                         precompiles.extend(additional_precompiles);
                     }
-
                     precompiles
                 });
-            })
-            .modify_tx_env(f)
-            .build();
+            })*/
+            .modify_tx_chained(f)
+            .build_mainnet();
 
         // Run the transaction.
         let tx_result = if estimate_gas {
-            match evm.transact() {
+            match evm.transact(evm.tx.clone()) {
                 Ok(result) => result.result,
                 Err(err) => return Err(crate::Error::ExecutionFailed(format!("{:?}", err))),
             }
         } else {
-            match evm.transact_commit() {
+            match evm.transact_commit(evm.tx.clone()) {
                 Ok(result) => result,
                 Err(err) => return Err(crate::Error::ExecutionFailed(format!("{:?}", err))),
             }
@@ -523,7 +520,7 @@ impl<Cfg: Config> Module<Cfg> {
                 .unwrap(); // XXX: err checking
 
             tx.caller = caller.0.into();
-            tx.transact_to = TxKind::Create;
+            tx.kind = TxKind::Create;
             tx.value = revm::primitives::U256::from_be_bytes(value.into());
             tx.data = init_code.into();
         })
@@ -544,7 +541,7 @@ impl<Cfg: Config> Module<Cfg> {
                 .unwrap(); // XXX: err checking
 
             tx.caller = caller.0.into();
-            tx.transact_to = TxKind::Call(address.0.into());
+            tx.kind = TxKind::Call(address.0.into());
             tx.value = revm::primitives::U256::from_be_bytes(value.into());
             tx.data = data.into();
         })

runtime-sdk/modules/evm-new/src/lib.rs

@@ -1,5 +1,5 @@
 //! Implements the confidential precompiles.
-use std::{collections::HashMap, convert::TryInto};
+/*use std::{collections::HashMap, convert::TryInto};
 
 use ethabi::{ParamType, Token};
 use hmac::{Hmac, Mac};
@@ -320,3 +320,4 @@ pub(super) fn call_verify(input: &Bytes, gas_limit: u64) -> PrecompileResult {
     let output = ethabi::encode(&[Token::Bool(result.is_ok())]);
     Ok(PrecompileOutput::new(cost, output.into()))
 }
+*/

runtime-sdk/modules/evm-new/src/precompile/confidential.rs

@@ -1,4 +1,4 @@
-use ethabi::{ParamType, Token};
+/*use ethabi::{ParamType, Token};
 use revm::{
     precompile::{PrecompileError, PrecompileOutput, PrecompileResult},
     primitives::{Bytes, Env},
@@ -49,3 +49,4 @@ pub(super) fn call_pad_gas(input: &Bytes, gas_limit: u64, _env: &Env) -> Precomp
 
     Ok(PrecompileOutput::new(cost, Bytes::new()))
 }
+*/

runtime-sdk/modules/evm-new/src/precompile/gas.rs

@@ -1,4 +1,4 @@
-use revm::precompile::{Address, Precompile, PrecompileWithAddress};
+use revm::{precompile::PrecompileWithAddress, primitives::Address};
 
 mod confidential;
 mod gas;
@@ -13,7 +13,9 @@ pub const fn oasis_addr(a18: u8, a19: u8) -> Address {
 }
 
 pub fn new() -> Vec<PrecompileWithAddress> {
-    vec![
+    // TODO: Port precompiles to the new revm API.
+    vec![]
+    /*vec![
         // Oasis-specific, confidential.
         // TODO: random_bytes
         /*PrecompileWithAddress(
@@ -62,5 +64,5 @@ pub fn new() -> Vec<PrecompileWithAddress> {
             Precompile::Env(subcall::call_subcall),
         ),*/
         PrecompileWithAddress(oasis_addr(1, 4), Precompile::Standard(sha2::call_sha384)),
-    ]
+    ]*/
 }

runtime-sdk/modules/evm-new/src/precompile/mod.rs

@@ -1,5 +1,5 @@
 //! Implements SHA2 precompiles.
-use revm::{
+/*use revm::{
     precompile::{calc_linear_cost_u32, PrecompileError, PrecompileOutput, PrecompileResult},
     primitives::Bytes,
 };
@@ -24,3 +24,4 @@ macro_rules! make_hasher {
 make_hasher!(call_sha512_256, Sha512_256);
 make_hasher!(call_sha384, Sha384);
 make_hasher!(call_sha512, Sha512);
+*/