Implementation of EIP-1153: Transient Storage using Disk Persistence and Lifecycle Management

Cargo.toml

@@ -137,7 +137,7 @@ fvm_shared = "4.5.1"
 fvm_ipld_encoding = "0.5.0"
 fvm_ipld_blockstore = "0.3.0"
 fvm_ipld_hamt = "0.10.2"
-fvm_ipld_kamt = "0.4.2"
+fvm_ipld_kamt = "0.4.3"
 fvm_ipld_amt = { version = "0.7.3" }
 fvm_ipld_bitfield = "0.7.0"
 

actors/evm/src/interpreter/execution.rs

@@ -163,6 +163,8 @@ pub mod opcodes {
         0x59: MSIZE,
         0x5a: GAS,
         0x5b: JUMPDEST,
+        0x5c: TLOAD,
+        0x5d: TSTORE,
         0x5e: MCOPY,
         0x5F: PUSH0,
         0x60: PUSH1,
@@ -400,6 +402,8 @@ mod tests {
             MSTORE8,
             SLOAD,
             SSTORE,
+            TLOAD,
+            TSTORE,
             LOG0,
             LOG1,
             LOG2,

actors/evm/src/interpreter/instructions/context.rs

@@ -153,7 +153,6 @@ mod tests {
     use cid::multihash::Multihash;
     use cid::Cid;
     use fil_actors_evm_shared::uints::U256;
-    use fil_actors_runtime::EAM_ACTOR_ID;
     use fvm_ipld_encoding::{DAG_CBOR, IPLD_RAW};
     use fvm_shared::address::Address as FilAddress;
 
@@ -364,25 +363,6 @@ mod tests {
         };
     }
 
-    #[test]
-    fn test_origin_ethaddr() {
-        let addr_bytes = hex_literal::hex!("FEEDFACECAFEBEEF000000000000000000001234");
-        let eth_addr = EthAddress(addr_bytes);
-        let fil_addr = FilAddress::new_delegated(EAM_ACTOR_ID, &addr_bytes).unwrap();
-        evm_unit_test! {
-            (rt) {
-                rt.in_call.replace(true);
-                rt.set_origin(fil_addr);
-            }
-            (m) {
-                ORIGIN;
-            }
-            m.step().expect("execution step failed");
-            assert_eq!(m.state.stack.len(), 1);
-            assert_eq!(m.state.stack.pop().unwrap(), eth_addr.as_evm_word());
-        };
-    }
-
     #[test]
     fn test_caller() {
         evm_unit_test! {

actors/evm/src/interpreter/instructions/mod.rs

@@ -338,6 +338,8 @@ def_stdproc! { MSTORE(a, b) => memory::mstore }
 def_stdproc! { MSTORE8(a, b) => memory::mstore8 }
 def_stdfun! { SLOAD(a) => storage::sload }
 def_stdproc! { SSTORE(a, b) => storage::sstore }
+def_stdfun! { TLOAD(a) => storage::tload }
+def_stdproc! { TSTORE(a, b) => storage::tstore }
 def_stdfun! { MSIZE() => memory::msize }
 def_stdfun! { GAS() => context::gas }
 def_stdlog! { LOG0(0, ()) }

actors/evm/src/interpreter/instructions/storage.rs

@@ -30,6 +30,30 @@ pub fn sstore(
     system.set_storage(key, value)
 }
 
+#[inline]
+pub fn tload(
+    _state: &mut ExecutionState,
+    system: &mut System<impl Runtime>,
+    location: U256,
+) -> Result<U256, ActorError> {
+    // get from storage and place on stack
+    system.get_transient_storage(location)
+}
+
+#[inline]
+pub fn tstore(
+    _state: &mut ExecutionState,
+    system: &mut System<impl Runtime>,
+    key: U256,
+    value: U256,
+) -> Result<(), ActorError> {
+    if system.readonly {
+        return Err(ActorError::read_only("store called while read-only".into()));
+    }
+
+    system.set_transient_storage(key, value)
+}
+
 #[cfg(test)]
 mod tests {
     use fil_actors_evm_shared::uints::U256;
@@ -82,4 +106,51 @@ mod tests {
             assert_eq!(m.system.get_storage(U256::from(0)).unwrap(), U256::from(0x42));
         };
     }
+
+    #[test]
+    fn test_tload() {
+        // happy path
+        evm_unit_test! {
+            (m) {
+                TLOAD;
+            }
+            m.system.set_transient_storage(U256::from(0), U256::from(0x42)).unwrap();
+            m.state.stack.push(U256::from(0)).unwrap();
+            let result = m.step();
+            assert!(result.is_ok(), "execution step failed");
+            assert_eq!(m.state.stack.len(), 1);
+            assert_eq!(m.state.stack.pop().unwrap(), U256::from(0x42));
+        };
+    }
+
+    #[test]
+    fn test_tload_oob() {
+        // oob access -- unitialized is zero
+        evm_unit_test! {
+            (m) {
+                TLOAD;
+            }
+            m.state.stack.push(U256::from(1234)).unwrap();
+            let result = m.step();
+            assert!(result.is_ok(), "execution step failed");
+            assert_eq!(m.state.stack.len(), 1);
+            assert_eq!(m.state.stack.pop().unwrap(), U256::from(0));
+        };
+    }
+
+    #[test]
+    fn test_tstore() {
+        evm_unit_test! {
+            (m) {
+                TSTORE;
+            }
+
+            m.state.stack.push(U256::from(0x42)).unwrap();
+            m.state.stack.push(U256::from(0)).unwrap();
+            let result = m.step();
+            assert!(result.is_ok(), "execution step failed");
+            assert_eq!(m.state.stack.len(), 0);
+            assert_eq!(m.system.get_transient_storage(U256::from(0)).unwrap(), U256::from(0x42));
+        };
+    }
 }

actors/evm/src/interpreter/precompiles/evm.rs

@@ -314,6 +314,8 @@ mod tests {
     #[test]
     fn bn_recover() {
         let rt = MockRuntime::default();
+        rt.in_call.replace(true);
+
         let mut system = System::create(&rt).unwrap();
 
         let input = &hex!(
@@ -357,6 +359,8 @@ mod tests {
         let input = "foo bar baz boxy".as_bytes();
 
         let rt = MockRuntime::default();
+        rt.in_call.replace(true);
+
         let mut system = System::create(&rt).unwrap();
 
         let expected = hex!("ace8597929092c14bd028ede7b07727875788c7e130278b5afed41940d965aba");
@@ -370,6 +374,8 @@ mod tests {
         let input = "foo bar baz boxy".as_bytes();
 
         let rt = MockRuntime::default();
+        rt.in_call.replace(true);
+
         let mut system = System::create(&rt).unwrap();
 
         let expected = hex!("0000000000000000000000004cd7a0452bd3d682e4cbd5fa90f446d7285b156a");
@@ -389,6 +395,8 @@ mod tests {
         );
 
         let rt = MockRuntime::default();
+        rt.in_call.replace(true);
+
         let mut system = System::create(&rt).unwrap();
 
         let expected = hex!("08");
@@ -450,6 +458,8 @@ mod tests {
         #[test]
         fn bn_add() {
             let rt = MockRuntime::default();
+            rt.in_call.replace(true);
+
             let mut system = System::create(&rt).unwrap();
 
             let input = hex::decode(
@@ -519,6 +529,8 @@ mod tests {
             ];
 
             let rt = MockRuntime::default();
+            rt.in_call.replace(true);
+
             let mut system = System::create(&rt).unwrap();
 
             for (f, name) in tests {
@@ -546,6 +558,8 @@ mod tests {
                 &[(blake2f, "fail-blake2f")];
 
             let rt = MockRuntime::default();
+            rt.in_call.replace(true);
+
             let mut system = System::create(&rt).unwrap();
 
             for (f, name) in failures {
@@ -561,6 +575,8 @@ mod tests {
         #[test]
         fn bn_mul() {
             let rt = MockRuntime::default();
+            rt.in_call.replace(true);
+
             let mut system = System::create(&rt).unwrap();
 
             let input = hex::decode(
@@ -614,6 +630,8 @@ mod tests {
         #[test]
         fn bn_pair() {
             let rt = MockRuntime::default();
+            rt.in_call.replace(true);
+
             let mut system = System::create(&rt).unwrap();
 
             let input = hex::decode(
@@ -701,6 +719,8 @@ mod tests {
     fn blake2() {
         use super::blake2f;
         let rt = MockRuntime::default();
+        rt.in_call.replace(true);
+
         let mut system = System::create(&rt).unwrap();
 
         // // helper to turn EIP test cases into something readable