Merge branch 'main' into bf-consensus-0.9

Author: brunoffranca

contracts

@@ -53,6 +53,7 @@ impl From<U64> for U64Number {
 // `Signature`, `keccak256`: from `web3::signing`
 
 /// A struct that represents the components of a secp256k1 signature.
+#[derive(Debug)]
 pub struct Signature {
     /// V component in Electrum format with chain-id replay protection.
     pub v: u64,

core/lib/basic_types/src/web3/mod.rs

@@ -270,16 +270,26 @@ pub fn read_bytecode_from_path(
 ) -> Option<Vec<u8>> {
     let artifact = read_file_to_json_value(&artifact_path)?;
 
-    let bytecode = if let Some(bytecode) = artifact["bytecode"].as_str() {
-        bytecode
-            .strip_prefix("0x")
-            .unwrap_or_else(|| panic!("Bytecode in {:?} is not hex", artifact_path))
-    } else {
-        artifact["bytecode"]["object"]
-            .as_str()
-            .unwrap_or_else(|| panic!("Bytecode not found in {:?}", artifact_path))
-    };
+    let bytecode = artifact["bytecode"]
+        .as_str()
+        .or_else(|| artifact["bytecode"]["object"].as_str())
+        .unwrap_or_else(|| panic!("Bytecode not found in {:?}", artifact_path));
+    // Strip an optional `0x` prefix.
+    let bytecode = bytecode.strip_prefix("0x").unwrap_or(bytecode);
+    Some(
+        hex::decode(bytecode)
+            .unwrap_or_else(|err| panic!("Can't decode bytecode in {:?}: {}", artifact_path, err)),
+    )
+}
 
+pub fn read_deployed_bytecode_from_path(artifact_path: &Path) -> Option<Vec<u8>> {
+    let artifact = read_file_to_json_value(artifact_path)?;
+    let bytecode = artifact["deployedBytecode"]
+        .as_str()
+        .or_else(|| artifact["deployedBytecode"]["object"].as_str())
+        .unwrap_or_else(|| panic!("Deployed bytecode not found in {:?}", artifact_path));
+    // Strip an optional `0x` prefix.
+    let bytecode = bytecode.strip_prefix("0x").unwrap_or(bytecode);
     Some(
         hex::decode(bytecode)
             .unwrap_or_else(|err| panic!("Can't decode bytecode in {:?}: {}", artifact_path, err)),

core/lib/contracts/src/lib.rs

@@ -180,7 +180,7 @@ impl Harness {
         let (compression_result, exec_result) =
             vm.execute_transaction_with_bytecode_compression(deploy_tx.tx.clone(), true);
         compression_result.unwrap();
-        assert!(!exec_result.result.is_failed(), "{:#?}", exec_result);
+        assert!(!exec_result.result.is_failed(), "{exec_result:#?}");
 
         let load_test_tx = self.bob.get_loadnext_transaction(
             deploy_tx.address,
@@ -190,7 +190,7 @@ impl Harness {
         let (compression_result, exec_result) =
             vm.execute_transaction_with_bytecode_compression(load_test_tx.clone(), true);
         compression_result.unwrap();
-        assert!(!exec_result.result.is_failed(), "{:#?}", exec_result);
+        assert!(!exec_result.result.is_failed(), "{exec_result:#?}");
 
         self.new_block(vm, &[deploy_tx.tx.hash(), load_test_tx.hash()]);
     }

core/lib/multivm/src/versions/shadow/mod.rs

@@ -247,6 +247,21 @@ mod call_tracer {
     fn recursive_tx() {
         test_recursive_tx::<super::ShadowedFastVm<_, _>>();
     }
+
+    #[test]
+    fn evm_to_eravm_call() {
+        test_evm_to_eravm_call::<super::ShadowedFastVm<_, _>>();
+    }
+
+    #[test]
+    fn evm_deployment_tx() {
+        test_evm_deployment_tx::<super::ShadowedFastVm<_, _>>();
+    }
+
+    #[test]
+    fn evm_deployment_from_contract() {
+        test_evm_deployment_from_contract::<super::ShadowedFastVm<_, _>>();
+    }
 }
 
 mod circuits {
@@ -291,10 +306,94 @@ mod default_aa {
     }
 }
 
-mod evm_emulator {
+mod evm {
+    use crate::versions::testonly::evm::*;
+
+    #[test]
+    fn evm_deployment_tx() {
+        test_evm_deployment_tx::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn evm_bytecode_decommit() {
+        test_evm_bytecode_decommit::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn real_emulator_basics() {
+        test_real_emulator_basics::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn real_emulator_code_hash() {
+        test_real_emulator_code_hash::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn real_emulator_block_info() {
+        test_real_emulator_block_info::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn real_emulator_msg_info() {
+        test_real_emulator_msg_info::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn real_emulator_gas_management() {
+        test_real_emulator_gas_management::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn real_emulator_recursion() {
+        test_real_emulator_recursion::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn real_emulator_deployment() {
+        test_real_emulator_deployment::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn deployment_with_partial_reverts() {
+        test_deployment_with_partial_reverts::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn era_vm_deployment_after_evm_execution() {
+        test_era_vm_deployment_after_evm_execution::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn era_vm_deployment_after_evm_deployment() {
+        test_era_vm_deployment_after_evm_deployment::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn calling_era_contract_from_evm() {
+        test_calling_era_contract_from_evm::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn far_calls_from_evm_contract() {
+        test_far_calls_from_evm_contract::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn calling_sha256_precompile() {
+        test_calling_sha256_precompile::<super::ShadowedFastVm>();
+    }
+
+    #[test]
+    fn calling_ecrecover_precompile() {
+        test_calling_ecrecover_precompile::<super::ShadowedFastVm>();
+    }
+}
+
+mod mock_evm {
     use test_casing::{test_casing, Product};
 
-    use crate::versions::testonly::evm_emulator::*;
+    use crate::versions::testonly::mock_evm::*;
 
     #[test]
     fn tracing_evm_contract_deployment() {

core/lib/multivm/src/versions/shadow/tests.rs

@@ -22,6 +22,10 @@ enum TestCase {
     RecursiveOutOfGas = 4,
     PlainOutOfGas = 5,
     PlainOutOfGasWithCatch = 6,
+    ReadFromMappings = 7,
+    DisallowedReadFromLayeredMapping = 8,
+    DisallowedReadFromMappingWithOffset = 9,
+    ReadFromMappingWithLargeOffset = 10,
 }
 
 /// Checks that every limitation imposed on account validation results in an appropriate error.
@@ -72,6 +76,30 @@ pub(crate) fn test_account_validation_rules<VM: TestedVm + TestedVmForValidation
             Some(ViolatedValidationRule::TookTooManyComputationalGas(_))
         );
     }
+
+    let (result, violated_rule) = test_rule::<VM>(u32::MAX, TestCase::ReadFromMappings);
+    assert!(!result.result.is_failed(), "{result:#?}");
+    assert_matches!(violated_rule, None);
+
+    for test_case in [
+        TestCase::DisallowedReadFromLayeredMapping,
+        TestCase::DisallowedReadFromMappingWithOffset,
+        TestCase::ReadFromMappingWithLargeOffset,
+    ] {
+        println!("Testing case: {test_case:?}");
+
+        let (result, violated_rule) = test_rule::<VM>(u32::MAX, test_case);
+        assert_matches!(
+            &result.result,
+            ExecutionResult::Halt {
+                reason: Halt::TracerCustom(_)
+            }
+        );
+        assert_matches!(
+            violated_rule,
+            Some(ViolatedValidationRule::TouchedDisallowedStorageSlots(_, _))
+        );
+    }
 }
 
 fn test_rule<VM: TestedVmForValidation>(
@@ -94,14 +122,31 @@ fn test_rule<VM: TestedVmForValidation>(
     );
 
     let bytecode = TestContract::validation_test().bytecode.to_vec();
+    let mut contracts = vec![ContractToDeploy::account(bytecode, aa_address).funded()];
+
+    if matches!(
+        test_case,
+        TestCase::ReadFromMappings
+            | TestCase::DisallowedReadFromLayeredMapping
+            | TestCase::DisallowedReadFromMappingWithOffset
+            | TestCase::ReadFromMappingWithLargeOffset
+    ) {
+        let token_address = Address::repeat_byte(0x23);
+        let bytecode = TestContract::validation_test_mock_token().bytecode.to_vec();
+        contracts.push(ContractToDeploy::new(bytecode, token_address));
+        // Set the mock token address in the AA contract.
+        storage_with_rule_break_set.set_value(
+            StorageKey::new(AccountTreeId::new(aa_address), H256::from_low_u64_be(2)),
+            address_to_h256(&token_address),
+        );
+    }
+
     let mut vm = VmTesterBuilder::new()
         .with_system_env(SystemEnv {
             default_validation_computational_gas_limit: validation_gas_limit,
             ..default_system_env()
         })
-        .with_custom_contracts(vec![
-            ContractToDeploy::account(bytecode, aa_address).funded()
-        ])
+        .with_custom_contracts(contracts)
         .with_storage(storage_with_rule_break_set)
         .with_execution_mode(TxExecutionMode::VerifyExecute)
         .with_rich_accounts(1)

core/lib/multivm/src/versions/testonly/account_validation_rules.rs

@@ -9,7 +9,6 @@ pub(crate) fn test_dummy_bootloader<VM: TestedVm>() {
     base_system_contracts.bootloader = get_bootloader("dummy");
 
     let mut vm = VmTesterBuilder::new()
-        .with_empty_in_memory_storage()
         .with_base_system_smart_contracts(base_system_contracts)
         .with_execution_mode(TxExecutionMode::VerifyExecute)
         .build::<VM>();
@@ -27,7 +26,6 @@ pub(crate) fn test_bootloader_out_of_gas<VM: TestedVm>() {
     base_system_contracts.bootloader = get_bootloader("dummy");
 
     let mut vm = VmTesterBuilder::new()
-        .with_empty_in_memory_storage()
         .with_base_system_smart_contracts(base_system_contracts)
         .with_bootloader_gas_limit(10)
         .with_execution_mode(TxExecutionMode::VerifyExecute)

core/lib/multivm/src/versions/testonly/bootloader.rs

@@ -10,7 +10,6 @@ pub(crate) fn test_bytecode_publishing<VM: TestedVm>() {
     // In this test, we aim to ensure that the contents of the compressed bytecodes
     // are included as part of the L2->L1 long messages
     let mut vm = VmTesterBuilder::new()
-        .with_empty_in_memory_storage()
         .with_execution_mode(TxExecutionMode::VerifyExecute)
         .with_rich_accounts(1)
         .build::<VM>();