wip test

Author: Stebalien

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

@@ -272,7 +272,8 @@ pub fn call_generic<RT: Runtime>(
                                 caller: state.caller,
                                 value: state.value_received.clone(),
                             };
-                            system
+                            eprintln!("begin delegate call");
+                            let res = system
                                 .send(
                                     &system.rt.message().receiver(),
                                     Method::InvokeContractDelegate as u64,
@@ -281,7 +282,9 @@ pub fn call_generic<RT: Runtime>(
                                     Some(effective_gas_limit(system, gas)),
                                     SendFlags::default(),
                                 )
-                                .map_err(|mut ae| ae.take_data())
+                                .map_err(|mut ae| ae.take_data());
+                            eprintln!("end delegate call");
+                            res
                         } else {
                             // If it doesn't have code, short-circuit and return immediately.
                             Ok(None)

actors/evm/src/interpreter/system.rs

@@ -244,7 +244,9 @@ impl<'r, RT: Runtime> System<'r, RT> {
         send_flags: SendFlags,
     ) -> Result<Result<Response, ErrorNumber>, ActorError> {
         self.flush()?;
+        eprintln!("begin send");
         let result = self.rt.send(to, method, params, value, gas_limit, send_flags);
+        eprintln!("end send");
 
         // Reload on success, and only on success.
         match &result {
@@ -290,6 +292,7 @@ impl<'r, RT: Runtime> System<'r, RT> {
 
         self.rt.set_state_root(&new_root)?;
         self.saved_state_root = Some(new_root);
+        eprintln!("flushed");
         Ok(())
     }
 
@@ -318,6 +321,17 @@ impl<'r, RT: Runtime> System<'r, RT> {
         self.saved_state_root = Some(root);
         self.bytecode = Some(EvmBytecode::new(state.bytecode, state.bytecode_hash));
         self.tombstone = state.tombstone;
+        eprintln!("reloaded");
+        self.slots
+            .for_each(|k, v| {
+                eprintln!(
+                    "reloaded slot: {} = {}",
+                    hex::encode(k.to_bytes()),
+                    hex::encode(v.to_bytes()),
+                );
+                Ok(())
+            })
+            .unwrap();
         Ok(())
     }
 
@@ -357,16 +371,32 @@ impl<'r, RT: Runtime> System<'r, RT> {
 
     /// Get value of a storage key.
     pub fn get_storage(&mut self, key: U256) -> Result<U256, ActorError> {
-        Ok(self
+        let value = self
             .slots
             .get(&key)
             .context_code(ExitCode::USR_ILLEGAL_STATE, "failed to clear storage slot")?
             .cloned()
-            .unwrap_or_default())
+            .unwrap_or_default();
+
+        let whoami = self.rt.message().receiver();
+
+        eprintln!(
+            "{whoami}: load {} = {}",
+            hex::encode(key.to_bytes()),
+            hex::encode(value.to_bytes())
+        );
+        Ok(value)
     }
 
     /// Set value of a storage key.
     pub fn set_storage(&mut self, key: U256, value: U256) -> Result<(), ActorError> {
+        let whoami = self.rt.message().receiver();
+
+        eprintln!(
+            "{whoami}: store {} = {}",
+            hex::encode(key.to_bytes()),
+            hex::encode(value.to_bytes())
+        );
         let changed = if value.is_zero() {
             self.slots
                 .delete(&key)

integration_tests/src/tests/evm_test.rs

@@ -725,6 +725,109 @@ pub fn evm_staticcall_delegatecall_test(v: &dyn VM) {
     }
 }
 
+#[allow(non_snake_case)]
+#[vm_test]
+pub fn evm_mint_test(v: &dyn VM) {
+    const IMP_INITCODE: &str = include_str!("./mint_contract/imp.hex");
+    const PROXY_INITCODE: &str = include_str!("./mint_contract/proxy.hex");
+
+    // Create accounts for deployment
+    let accounts = create_accounts(v, 2, &TokenAmount::from_whole(10_000));
+    let deployer = &accounts[0];
+
+    eprintln!(">> deploying impl");
+
+    // 1. Deploy the implementation contract
+    let imp_bytecode = hex::decode(IMP_INITCODE).unwrap();
+    let imp_deploy_result = v
+        .execute_message(
+            deployer,
+            &EAM_ACTOR_ADDR,
+            &TokenAmount::zero(),
+            fil_actor_eam::Method::CreateExternal as u64,
+            Some(serialize_ok(&fil_actor_eam::CreateExternalParams(imp_bytecode))),
+        )
+        .unwrap();
+
+    assert!(
+        imp_deploy_result.code.is_success(),
+        "Failed to deploy implementation contract: {}",
+        imp_deploy_result.message
+    );
+
+    let imp_return: fil_actor_eam::CreateExternalReturn = imp_deploy_result
+        .ret
+        .unwrap()
+        .deserialize()
+        .expect("Failed to decode implementation deployment results");
+
+    // Make sure we deployed an EVM actor
+    assert_eq!(&v.actor(&Address::new_id(imp_return.actor_id)).unwrap().code, &*EVM_ACTOR_CODE_ID);
+
+    let implementation_eth_addr = imp_return.eth_address;
+
+    // 2. Deploy the proxy contract with implementation address in constructor
+    let proxy_initcode_fixed = PROXY_INITCODE.replace(
+        "606fa930c2f5eae4116ac5c1c93e1dbbe9957113",
+        &hex::encode(implementation_eth_addr.0),
+    );
+    let proxy_initcode = hex::decode(proxy_initcode_fixed).unwrap();
+
+    eprintln!(">> deploying proxy");
+
+    let proxy_deploy_result = v
+        .execute_message(
+            deployer,
+            &EAM_ACTOR_ADDR,
+            &TokenAmount::zero(),
+            fil_actor_eam::Method::CreateExternal as u64,
+            Some(serialize_ok(&fil_actor_eam::CreateExternalParams(proxy_initcode))),
+        )
+        .unwrap();
+
+    assert!(
+        proxy_deploy_result.code.is_success(),
+        "Failed to deploy proxy contract: {}",
+        proxy_deploy_result.message
+    );
+
+    let proxy_return: fil_actor_eam::CreateExternalReturn = proxy_deploy_result
+        .ret
+        .unwrap()
+        .deserialize()
+        .expect("Failed to decode proxy deployment results");
+
+    let proxy_robust_addr = proxy_return.robust_address.unwrap();
+
+    eprintln!(">> checking role");
+
+    // Check if deployer has the admin role, it should!
+    // I can confirm that the admin role hash below is correct because it shows up in 3 storage slots, see:
+    // https://github.com/recallnet/contracts/blob/06ec52342ffe6cd29cb9c06ebf5a785f4a057c0e/src/token/Recall.sol#L54-L56
+    const PARAMS_PREFIX: &str = "91d14854a49807205ce4d355092ef5a8a18f56e8913cf4a201fbe287825b095693c21775000000000000000000000000";
+    let mut has_role_params = hex::decode(PARAMS_PREFIX).unwrap();
+    has_role_params.extend_from_slice(&id_to_eth(deployer.id().unwrap()).0[..]);
+
+    let has_role_result = v
+        .execute_message(
+            &deployer,
+            &proxy_robust_addr,
+            &TokenAmount::zero(),
+            fil_actor_evm::Method::InvokeContract as u64,
+            Some(serialize_ok(&ContractParams(has_role_params))),
+        )
+        .unwrap();
+
+    assert!(has_role_result.code.is_success(), "Failed to check role: {}", has_role_result.message);
+    let BytesDe(return_value) =
+        has_role_result.ret.unwrap().deserialize().expect("failed to deserialize results");
+    assert_eq!(
+        hex::encode(return_value),
+        "0000000000000000000000000000000000000000000000000000000000000001"
+    );
+}
+
+#[allow(non_snake_case)]
 #[vm_test]
 pub fn evm_init_revert_data_test(v: &dyn VM) {
     let account = create_accounts(v, 1, &TokenAmount::from_whole(10_000))[0];

integration_tests/src/tests/mint_contract/imp.hex

@@ -0,0 +1 @@
+60806040526102a88038038061001481610168565b92833981016040828203126101645781516001600160a01b03811692909190838303610164576020810151906001600160401b03821161016457019281601f8501121561016457835161006e610069826101a1565b610168565b9481865260208601936020838301011161016457815f926020809301865e86010152823b15610152577f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b031916821790557fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f80a282511561013a575f8091610122945190845af43d15610132573d91610113610069846101a1565b9283523d5f602085013e6101bc565b505b604051608d908161021b8239f35b6060916101bc565b50505034156101245763b398979f60e01b5f5260045ffd5b634c9c8ce360e01b5f5260045260245ffd5b5f80fd5b6040519190601f01601f191682016001600160401b0381118382101761018d57604052565b634e487b7160e01b5f52604160045260245ffd5b6001600160401b03811161018d57601f01601f191660200190565b906101e057508051156101d157805190602001fd5b630a12f52160e11b5f5260045ffd5b81511580610211575b6101f1575090565b639996b31560e01b5f9081526001600160a01b0391909116600452602490fd5b50803b156101e956fe60806040525f8073ffffffffffffffffffffffffffffffffffffffff7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5416368280378136915af43d5f803e156053573d5ff35b3d5ffdfea264697066735822122030c28b2107e8964fdd1443848d1ee8bca67e339954e46faf8c26c065c85a3f3664736f6c634300081a0033000000000000000000000000606fa930c2f5eae4116ac5c1c93e1dbbe995711300000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000044be13f47c000000000000000000000000b5fb4be02232b1bba4dc8f81dc24c26980de9e3c341bb76302c76fb57d6fe6c003c4fc68e56cbe5c5a4c04bedf1522a15c7e41a000000000000000000000000000000000000000000000000000000000

integration_tests/src/tests/mint_contract/proxy.hex

@@ -54,6 +54,14 @@ fn evm_staticcall_delegatecall() {
     evm_staticcall_delegatecall_test(&v);
 }
 
+#[test]
+fn evm_mint() {
+    use fil_actors_integration_tests::tests::evm_mint_test;
+    let store = MemoryBlockstore::new();
+    let v = TestVM::new_with_singletons(store);
+    evm_mint_test(&v);
+}
+
 #[test]
 fn evm_init_revert_data() {
     let store = MemoryBlockstore::new();