feat: Use stateful instruction in AUTH

Cargo.toml

@@ -50,25 +50,21 @@ alphanet-precompile = { path = "crates/precompile" }
 tokio = { version = "1.21", default-features = false }
 
 # reth
-reth = { git = "https://github.com/paradigmxyz/reth.git", rev = "82b6504", features = ["optimism"] }
-reth-node-api = { git = "https://github.com/paradigmxyz/reth.git", rev = "82b6504" }
-reth-node-optimism = { git = "https://github.com/paradigmxyz/reth.git", rev = "82b6504" }
-reth-tracing = { git = "https://github.com/paradigmxyz/reth.git", rev = "82b6504" }
+reth = { git = "https://github.com/paradigmxyz/reth.git", rev = "1a42b09", features = ["optimism"] }
+reth-node-api = { git = "https://github.com/paradigmxyz/reth.git", rev = "1a42b09" }
+reth-node-optimism = { git = "https://github.com/paradigmxyz/reth.git", rev = "1a42b09" }
+reth-tracing = { git = "https://github.com/paradigmxyz/reth.git", rev = "1a42b09" }
 
 # revm
-revm = { version = "7.1.0", features = ["std", "secp256k1"], default-features = false }
-revm-inspectors = { git = "https://github.com/paradigmxyz/evm-inspectors", rev = "1f935e7" }
-revm-interpreter = { version = "3.3.0", features = ["std"], default-features = false }
-revm-precompile = { version = "5.0.0", features = ["std"], default-features = false }
-revm-primitives = { version = "3.0.0", features = ["std"], default-features = false }
+revm = { version = "7.2.0", features = ["std", "secp256k1"], default-features = false }
+revm-inspectors = { git = "https://github.com/paradigmxyz/evm-inspectors", rev = "2b48b65" }
+revm-interpreter = { version = "3.4.0", features = ["std"], default-features = false }
+revm-precompile = { version = "5.1.0", features = ["std"], default-features = false }
+revm-primitives = { version = "3.1.0", features = ["std"], default-features = false }
 
 # misc
 clap = "4"
 eyre = "0.6.12"
-secp256k1 = { version = "0.28.2", default-features = false, features = [
-    "alloc",
-    "recovery",
-] }
 tracing = "0.1.0"
 
 # misc-testing

bin/alphanet/Cargo.toml

@@ -19,14 +19,14 @@ reth-node-optimism.workspace = true
 clap = { workspace = true, features = ["derive"] }
 
 [target.'cfg(not(windows))'.dependencies]
-jemallocator = { version = "0.5", optional = true }
+tikv-jemallocator = { version = "0.5", optional = true }
 
 [features]
 default = ["jemalloc"]
 asm-keccak = []
 
-jemalloc = ["dep:jemallocator"]
-jemalloc-prof = ["jemalloc", "jemallocator?/profiling"]
+jemalloc = ["dep:tikv-jemallocator"]
+jemalloc-prof = ["jemalloc", "tikv-jemallocator?/profiling"]
 
 min-error-logs = ["tracing/release_max_level_error"]
 min-warn-logs = ["tracing/release_max_level_warn"]

bin/alphanet/src/main.rs

@@ -16,7 +16,7 @@ use reth_node_optimism::{args::RollupArgs, OptimismEngineTypes, OptimismNode};
 // We use jemalloc for performance reasons.
 #[cfg(all(feature = "jemalloc", unix))]
 #[global_allocator]
-static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
+static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
 fn main() {
     reth::sigsegv_handler::install();

crates/instructions/Cargo.toml

@@ -12,8 +12,8 @@ categories.workspace = true
 [dependencies]
 revm.workspace = true
 revm-interpreter.workspace = true
+revm-precompile.workspace = true
 revm-primitives.workspace = true
-secp256k1.workspace = true
 
 [dev-dependencies]
 secp256k1 = { version = "0.28.2", default-features = false, features = [

crates/instructions/src/context.rs

@@ -0,0 +1,110 @@
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
+
+#[derive(Clone, Default)]
+/// Context variables to be used in instructions. The data set here is expected
+/// to live for the duration of a single transaction.
+/// Similar to TStore for arbitrary data.
+pub struct InstructionsContext {
+    /// Contains the actual variables. Is meant to be accessed both for reads
+    /// and writes using interior mutability, so that the Instruction and
+    /// BoxedInstruction signatures are observed.
+    inner: Rc<RefCell<HashMap<&'static str, Vec<u8>>>>,
+}
+
+impl InstructionsContext {
+    /// Sets a value for the given key.
+    pub fn set(&self, key: &'static str, value: Vec<u8>) {
+        let _ = self.inner.borrow_mut().insert(key, value);
+    }
+
+    /// Gets the value for the given key, if any.
+    pub fn get(&self, key: &'static str) -> Option<Vec<u8>> {
+        self.inner.borrow().get(&key).cloned()
+    }
+
+    /// Empties inner state.
+    pub fn clear(&self) {
+        self.inner.borrow_mut().clear();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use revm::{Evm, InMemoryDB};
+    use revm_interpreter::Interpreter;
+    use revm_primitives::{address, AccountInfo, Bytecode, TransactTo, U256};
+    use std::sync::Arc;
+
+    #[test]
+    fn test_set_get() {
+        let ctx = InstructionsContext::default();
+        let key = "my-key";
+        let value = vec![0x01, 0x02];
+
+        ctx.set(key, value.clone());
+
+        let cloned_ctx = ctx.clone();
+        assert_eq!(cloned_ctx.get(key).unwrap(), value);
+    }
+
+    #[test]
+    fn test_context_variables_are_available_during_tx() {
+        let code = Bytecode::new_raw([0xEE, 0xEF, 0x00].into());
+        let code_hash = code.hash_slow();
+        let to_addr = address!("ffffffffffffffffffffffffffffffffffffffff");
+
+        // initialize the custom context and make sure it's None for a given key
+        let custom_context = InstructionsContext::default();
+        let key = "my-key";
+        assert_eq!(custom_context.get(key), None);
+
+        let to_capture_instructions = custom_context.clone();
+        let to_capture_post_execution = custom_context.clone();
+        let mut evm = Evm::builder()
+            .with_db(InMemoryDB::default())
+            .modify_db(|db| {
+                db.insert_account_info(to_addr, AccountInfo::new(U256::ZERO, 0, code_hash, code))
+            })
+            .modify_tx_env(|tx| tx.transact_to = TransactTo::Call(to_addr))
+            .append_handler_register_box(Box::new(move |handler| {
+                let writer_context = to_capture_instructions.clone();
+                let writer_instruction = Box::new(
+                    move |_interp: &mut Interpreter, _host: &mut Evm<'_, (), InMemoryDB>| {
+                        // write into the context variable.
+                        writer_context.set(key, vec![0x01, 0x02]);
+                    },
+                );
+                let reader_context = to_capture_instructions.clone();
+                let reader_instruction = Box::new(
+                    move |_interp: &mut Interpreter, _host: &mut Evm<'_, (), InMemoryDB>| {
+                        // read from context variable and clear.
+                        assert_eq!(reader_context.get(key).unwrap(), vec![0x01, 0x02]);
+                    },
+                );
+
+                let mut table = handler.take_instruction_table();
+                table = table.map(|mut table| {
+                    table.insert_boxed(0xEE, writer_instruction);
+                    table.insert_boxed(0xEF, reader_instruction);
+                    table
+                });
+                handler.instruction_table = table;
+
+                let post_execution_context = to_capture_post_execution.clone();
+                #[allow(clippy::arc_with_non_send_sync)]
+                {
+                    handler.post_execution.end = Arc::new(move |_, outcome: _| {
+                        post_execution_context.clear();
+                        outcome
+                    });
+                }
+            }))
+            .build();
+
+        let _result_and_state = evm.transact().unwrap();
+
+        // ensure the custom context was cleared
+        assert_eq!(custom_context.get(key), None);
+    }
+}