EVM runtime: implement GetBytecode and GetStorageAt getters.

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

@@ -205,11 +205,11 @@ pub fn call<'r, BS: Blockstore, RT: Runtime<BS>>(
     // TODO this limits addressable output to 2G (31 bits full),
     //      but it is still probably too much and we should consistently limit further.
     //      See also https://github.com/filecoin-project/ref-fvm/issues/851
-    let output_usize = if output_size.bits() < 32 {
-        output_size.as_usize()
-    } else {
+    if output_size.bits() >= 32 {
         return Err(StatusCode::InvalidMemoryAccess);
-    };
+    }
+    let output_usize = output_size.as_usize();
+
     if output_usize > 0 {
         let output_region = get_memory_region(memory, output_offset, output_size)
             .map_err(|_| StatusCode::InvalidMemoryAccess)?;

actors/evm/src/lib.rs

@@ -5,6 +5,7 @@ use {
     crate::interpreter::{execute, Bytecode, ExecutionState, StatusCode, System, U256},
     crate::state::State,
     bytes::Bytes,
+    cid::Cid,
     fil_actors_runtime::{
         actor_error, cbor,
         runtime::{ActorCode, Runtime},
@@ -32,6 +33,8 @@ const MAX_CODE_SIZE: usize = 24 << 10;
 pub enum Method {
     Constructor = METHOD_CONSTRUCTOR,
     InvokeContract = 2,
+    GetBytecode = 3,
+    GetStorageAt = 4,
 }
 
 pub struct EvmContractActor;
@@ -173,6 +176,48 @@ impl EvmContractActor {
         let output = RawBytes::from(exec_status.output_data.to_vec());
         Ok(output)
     }
+
+    pub fn bytecode<BS, RT>(rt: &mut RT) -> Result<Cid, ActorError>
+    where
+        BS: Blockstore + Clone,
+        RT: Runtime<BS>,
+    {
+        // Any caller can fetch the bytecode of a contract; this is now EXT* opcodes work.
+        rt.validate_immediate_caller_accept_any()?;
+
+        let state: State = rt.state()?;
+        Ok(state.bytecode)
+    }
+
+    pub fn storage_at<BS, RT>(rt: &mut RT, params: GetStorageAtParams) -> Result<U256, ActorError>
+    where
+        BS: Blockstore + Clone,
+        RT: Runtime<BS>,
+    {
+        // This method cannot be called on-chain; other on-chain logic should not be able to
+        // access arbitrary storage keys from a contract.
+        rt.validate_immediate_caller_is([&fvm_shared::address::Address::new_id(0)])?;
+
+        let state: State = rt.state()?;
+        let blockstore = rt.store().clone();
+
+        // load the storage HAMT
+        let mut hamt =
+            Hamt::<_, _, U256>::load(&state.contract_state, blockstore).map_err(|e| {
+                ActorError::illegal_state(format!(
+                    "failed to load storage HAMT on invoke: {e:?}, e"
+                ))
+            })?;
+
+        let mut system = System::new(rt, &mut hamt).map_err(|e| {
+            ActorError::unspecified(format!("failed to create execution abstraction layer: {e:?}"))
+        })?;
+
+        system
+            .get_storage(params.storage_key)
+            .map_err(|st| ActorError::unspecified(format!("failed to get storage key: {}", &st)))?
+            .ok_or_else(|| ActorError::not_found(String::from("storage key not found")))
+    }
 }
 
 impl ActorCode for EvmContractActor {
@@ -193,6 +238,14 @@ impl ActorCode for EvmContractActor {
             Some(Method::InvokeContract) => {
                 Self::invoke_contract(rt, cbor::deserialize_params(params)?)
             }
+            Some(Method::GetBytecode) => {
+                let cid = Self::bytecode(rt)?;
+                Ok(RawBytes::serialize(cid)?)
+            }
+            Some(Method::GetStorageAt) => {
+                let value = Self::storage_at(rt, cbor::deserialize_params(params)?)?;
+                Ok(RawBytes::serialize(value)?)
+            }
             None => Err(actor_error!(unhandled_message; "Invalid method")),
         }
     }
@@ -208,3 +261,8 @@ pub struct ConstructorParams {
 pub struct InvokeParams {
     pub input_data: RawBytes,
 }
+
+#[derive(Serialize_tuple, Deserialize_tuple)]
+pub struct GetStorageAtParams {
+    pub storage_key: U256,
+}

actors/evm/tests/basic.rs

@@ -1,6 +1,11 @@
+mod asm;
+
+use cid::Cid;
 use evm::interpreter::U256;
 use fil_actor_evm as evm;
 use fil_actors_runtime::test_utils::*;
+use fil_actors_runtime::ActorError;
+use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::address::Address;
 
@@ -72,3 +77,122 @@ fn basic_contract_construction_and_invocation() {
         .unwrap();
     assert_eq!(U256::from_big_endian(&result), U256::from(10000));
 }
+
+#[test]
+fn basic_get_bytecode() {
+    let (init_code, verbatim_body) = {
+        let init = "";
+        let body = r#"
+# get call payload size
+push1 0x20
+calldatasize
+sub
+# store payload to mem 0x00
+push1 0x20
+push1 0x00
+calldatacopy
+return
+"#;
+
+        let body_bytecode = {
+            let mut ret = Vec::new();
+            let mut ingest = etk_asm::ingest::Ingest::new(&mut ret);
+            ingest.ingest("body", body).unwrap();
+            ret
+        };
+
+        (asm::new_contract("get_bytecode", init, body).unwrap(), body_bytecode)
+    };
+
+    let mut rt = MockRuntime::default();
+
+    rt.expect_validate_caller_any();
+    let params =
+        evm::ConstructorParams { bytecode: init_code.into(), input_data: RawBytes::default() };
+    let result = rt
+        .call::<evm::EvmContractActor>(
+            evm::Method::Constructor as u64,
+            &RawBytes::serialize(params).unwrap(),
+        )
+        .unwrap();
+    expect_empty(result);
+    rt.verify();
+    rt.reset();
+
+    rt.expect_validate_caller_any();
+    let returned_bytecode_cid: Cid = rt
+        .call::<evm::EvmContractActor>(evm::Method::GetBytecode as u64, &Default::default())
+        .unwrap()
+        .deserialize()
+        .unwrap();
+    rt.verify();
+
+    let bytecode = rt.store.get(&returned_bytecode_cid).unwrap().unwrap();
+
+    assert_eq!(bytecode.as_slice(), verbatim_body.as_slice());
+}
+
+#[test]
+fn basic_get_storage_at() {
+    let init_code = {
+        // Initialize storage entry on key 0x8965 during init.
+        let init = r"
+push2 0xfffa
+push2 0x8965
+sstore";
+        let body = r#"return"#;
+
+        asm::new_contract("get_storage_at", init, body).unwrap()
+    };
+
+    let mut rt = MockRuntime::default();
+
+    rt.expect_validate_caller_any();
+    let params =
+        evm::ConstructorParams { bytecode: init_code.into(), input_data: RawBytes::default() };
+    let result = rt
+        .call::<evm::EvmContractActor>(
+            evm::Method::Constructor as u64,
+            &RawBytes::serialize(params).unwrap(),
+        )
+        .unwrap();
+    expect_empty(result);
+    rt.verify();
+    rt.reset();
+
+    let params = evm::GetStorageAtParams { storage_key: 0x8965.into() };
+
+    let sender = Address::new_id(0); // zero address because this method is not invokable on-chain
+    rt.expect_validate_caller_addr(vec![sender]);
+    rt.caller = sender;
+
+    //
+    // Get the storage key that was initialized in the init code.
+    //
+    let value: U256 = rt
+        .call::<evm::EvmContractActor>(
+            evm::Method::GetStorageAt as u64,
+            &RawBytes::serialize(params).unwrap(),
+        )
+        .unwrap()
+        .deserialize()
+        .unwrap();
+    rt.verify();
+    rt.reset();
+
+    assert_eq!(U256::from(0xfffa), value);
+
+    //
+    // Get a storage key that doesn't exist.
+    //
+    let params = evm::GetStorageAtParams { storage_key: 0xaaaa.into() };
+
+    rt.expect_validate_caller_addr(vec![sender]);
+    let ret = rt.call::<evm::EvmContractActor>(
+        evm::Method::GetStorageAt as u64,
+        &RawBytes::serialize(params).unwrap(),
+    );
+    rt.verify();
+
+    assert_eq!(ActorError::not_found("storage key not found".to_string()), ret.err().unwrap());
+}