blockifier: add l3 compatibility for addresses

einat-starkware · einat-starkware · commit 8744a20b2a77 · 2025-07-03T15:31:04.000+03:00
diff --git a/crates/apollo_batcher/src/cende_client_types.rs b/crates/apollo_batcher/src/cende_client_types.rs
@@ -255,7 +255,7 @@ fn get_l2_to_l1_messages(execution_info: &TransactionExecutionInfo) -> Vec<L2ToL
         let messages =
             call.execution.l2_to_l1_messages.iter().map(|l2_to_l1_message| L2ToL1Message {
                 from_address: call.call.caller_address,
-                to_address: l2_to_l1_message.message.to_address,
+                to_address: EthAddress::try_from(l2_to_l1_message.message.to_address).unwrap(),
                 payload: l2_to_l1_message.message.payload.clone(),
             });
         l2_to_l1_messages.extend(messages);
diff --git a/crates/apollo_consensus_orchestrator/src/cende/central_objects_test.rs b/crates/apollo_consensus_orchestrator/src/cende/central_objects_test.rs
@@ -79,7 +79,7 @@ use starknet_api::block::{
 };
 use starknet_api::consensus_transaction::InternalConsensusTransaction;
 use starknet_api::contract_class::{ContractClass, EntryPointType, SierraVersion};
-use starknet_api::core::{ClassHash, CompiledClassHash, EntryPointSelector, EthAddress};
+use starknet_api::core::{ClassHash, CompiledClassHash, EntryPointSelector, L1Address};
 use starknet_api::data_availability::{DataAvailabilityMode, L1DataAvailabilityMode};
 use starknet_api::executable_transaction::L1HandlerTransaction;
 use starknet_api::execution_resources::{GasAmount, GasVector};
@@ -502,7 +502,7 @@ fn call_info() -> CallInfo {
             l2_to_l1_messages: vec![OrderedL2ToL1Message {
                 order: 1,
                 message: MessageToL1 {
-                    to_address: EthAddress::try_from(felt!(1_u8)).unwrap(),
+                    to_address: L1Address::from(felt!(1_u8)),
                     payload: L2ToL1Payload(felt_vector()),
                 },
             }],
diff --git a/crates/apollo_rpc_execution/src/objects.rs b/crates/apollo_rpc_execution/src/objects.rs
@@ -29,6 +29,7 @@ use starknet_api::core::{
     ClassHash,
     ContractAddress,
     EntryPointSelector,
+    EthAddress,
     Nonce,
     SequencerContractAddress,
 };
@@ -463,7 +464,7 @@ impl OrderedL2ToL1Message {
             order: blockifier_message.order,
             message: MessageToL1 {
                 from_address,
-                to_address: blockifier_message.message.to_address,
+                to_address: EthAddress::try_from(blockifier_message.message.to_address).unwrap(),
                 payload: blockifier_message.message.payload,
             },
         }
diff --git a/crates/blockifier/src/execution/call_info.rs b/crates/blockifier/src/execution/call_info.rs
@@ -6,7 +6,7 @@ use cairo_vm::types::builtin_name::BuiltinName;
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
 use serde::Serialize;
 use starknet_api::block::{BlockHash, BlockNumber};
-use starknet_api::core::{ClassHash, ContractAddress, EthAddress};
+use starknet_api::core::{ClassHash, ContractAddress, L1Address};
 use starknet_api::execution_resources::{GasAmount, GasVector};
 use starknet_api::state::StorageKey;
 use starknet_api::transaction::fields::GasVectorComputationMode;
@@ -43,7 +43,7 @@ pub struct OrderedEvent {
 #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))]
 #[derive(Debug, Default, Eq, PartialEq, Serialize)]
 pub struct MessageToL1 {
-    pub to_address: EthAddress,
+    pub to_address: L1Address,
     pub payload: L2ToL1Payload,
 }
 
diff --git a/crates/blockifier/src/execution/deprecated_syscalls/mod.rs b/crates/blockifier/src/execution/deprecated_syscalls/mod.rs
@@ -6,7 +6,7 @@ use deprecated_syscall_executor::{
 };
 use serde::Deserialize;
 use starknet_api::block::{BlockNumber, BlockTimestamp};
-use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, EthAddress};
+use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector};
 use starknet_api::state::StorageKey;
 use starknet_api::transaction::fields::{Calldata, ContractAddressSalt};
 use starknet_api::transaction::{EventContent, EventData, EventKey, L2ToL1Payload};
@@ -424,7 +424,8 @@ impl SyscallRequest for SendMessageToL1Request {
         vm: &VirtualMachine,
         ptr: &mut Relocatable,
     ) -> DeprecatedSyscallExecutorBaseResult<SendMessageToL1Request> {
-        let to_address = EthAddress::try_from(felt_from_ptr(vm, ptr)?)?;
+        let felt_to_address = felt_from_ptr(vm, ptr)?;
+        let to_address = felt_to_address.into();
         let payload =
             L2ToL1Payload(read_felt_array::<DeprecatedSyscallExecutorBaseError>(vm, ptr)?);
 
diff --git a/crates/blockifier/src/execution/native/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs
@@ -568,8 +568,15 @@ impl StarknetSyscallHandler for &mut NativeSyscallHandler<'_> {
             self.gas_costs().syscalls.send_message_to_l1.base_syscall_cost(),
         )?;
 
-        let to_address = EthAddress::try_from(to_address)
-            .map_err(|err| self.handle_error(remaining_gas, err.into()))?;
+        if !self.base.context.tx_context.block_context.chain_info.is_layer_3 {
+            let err = SyscallExecutorBaseError::InvalidSyscallInExecutionMode;
+
+            EthAddress::try_from(to_address)
+                .map_err(|err| self.handle_error(remaining_gas, err.into()))?;
+        }
+
+        let to_address =
+            to_address.into().map_err(|err| self.handle_error(remaining_gas, err.into()))?;
         let message = MessageToL1 { to_address, payload: L2ToL1Payload(payload.to_vec()) };
 
         self.base.send_message_to_l1(message).map_err(|err| self.handle_error(remaining_gas, err))
diff --git a/crates/blockifier/src/execution/syscalls/syscall_tests/send_message_to_l1.rs b/crates/blockifier/src/execution/syscalls/syscall_tests/send_message_to_l1.rs
@@ -42,7 +42,7 @@ fn test_send_message_to_l1(runnable_version: RunnableCairo1) {
         ..trivial_external_entry_point_new(test_contract)
     };
 
-    let to_address = EthAddress::try_from(to_address).unwrap();
+    let to_address = EthAddress::try_from(to_address).unwrap().into();
     let message = MessageToL1 { to_address, payload: L2ToL1Payload(payload) };
 
     let mut execution = entry_point_call.execute_directly(&mut state).unwrap().execution;
@@ -58,8 +58,8 @@ fn test_send_message_to_l1(runnable_version: RunnableCairo1) {
                 OrderedL2ToL1Message {
                     order: 0,
                     message: MessageToL1 {
-                        to_address: EthAddress(
-                            0x00000000000000000000000000000000000004d2,
+                        to_address: L1Address(
+                            0x4d2,
                         ),
                         payload: L2ToL1Payload(
                             [
diff --git a/crates/blockifier/src/execution/syscalls/vm_syscall_utils.rs b/crates/blockifier/src/execution/syscalls/vm_syscall_utils.rs
@@ -9,7 +9,7 @@ use cairo_vm::vm::errors::vm_errors::VirtualMachineError;
 use cairo_vm::vm::vm_core::VirtualMachine;
 use num_traits::ToPrimitive;
 use starknet_api::block::{BlockHash, BlockNumber};
-use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, EthAddress};
+use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector};
 use starknet_api::execution_resources::GasAmount;
 use starknet_api::state::StorageKey;
 use starknet_api::transaction::fields::{Calldata, ContractAddressSalt, TransactionSignature};
@@ -404,7 +404,8 @@ impl SyscallRequest for SendMessageToL1Request {
         vm: &VirtualMachine,
         ptr: &mut Relocatable,
     ) -> SyscallBaseResult<SendMessageToL1Request> {
-        let to_address = EthAddress::try_from(felt_from_ptr(vm, ptr)?)?;
+        let felt_to_address = felt_from_ptr(vm, ptr)?;
+        let to_address = felt_to_address.into();
         let payload = L2ToL1Payload(read_felt_array::<SyscallExecutorBaseError>(vm, ptr)?);
 
         Ok(SendMessageToL1Request { message: MessageToL1 { to_address, payload } })
diff --git a/crates/blockifier/src/transaction/objects_test.rs b/crates/blockifier/src/transaction/objects_test.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use rstest::rstest;
-use starknet_api::core::{ClassHash, ContractAddress, EthAddress};
+use starknet_api::core::{ClassHash, ContractAddress, L1Address};
 use starknet_api::execution_resources::GasAmount;
 use starknet_api::state::StorageKey;
 use starknet_api::transaction::L2ToL1Payload;
@@ -65,7 +65,7 @@ impl TestExecutionSummary {
                     .map(|i| OrderedL2ToL1Message {
                         order: i,
                         message: MessageToL1 {
-                            to_address: EthAddress::default(),
+                            to_address: L1Address::default(),
                             payload: L2ToL1Payload(vec![Felt::default()]),
                         },
                     })
diff --git a/crates/blockifier/src/transaction/transactions_test.rs b/crates/blockifier/src/transaction/transactions_test.rs
@@ -20,7 +20,7 @@ use starknet_api::abi::abi_utils::{
 use starknet_api::abi::constants::CONSTRUCTOR_ENTRY_POINT_NAME;
 use starknet_api::block::{FeeType, GasPriceVector};
 use starknet_api::contract_class::EntryPointType;
-use starknet_api::core::{ascii_as_felt, ClassHash, ContractAddress, EthAddress, Nonce};
+use starknet_api::core::{ascii_as_felt, ClassHash, ContractAddress, Nonce};
 use starknet_api::executable_transaction::{
     AccountTransaction as ApiExecutableTransaction,
     DeployAccountTransaction,
@@ -951,7 +951,7 @@ fn test_invoke_tx_advanced_operations(
     let expected_msg = OrderedL2ToL1Message {
         order: 0,
         message: MessageToL1 {
-            to_address: EthAddress::try_from(to_address).unwrap(),
+            to_address: to_address.into(),
             payload: L2ToL1Payload(vec![felt!(12_u32), felt!(34_u32)]),
         },
     };
diff --git a/crates/starknet_api/src/core.rs b/crates/starknet_api/src/core.rs
@@ -461,6 +461,51 @@ macro_rules! contract_address {
 #[serde(try_from = "PrefixedBytesAsHex<20_usize>", into = "PrefixedBytesAsHex<20_usize>")]
 pub struct EthAddress(pub H160);
 
+#[derive(
+    Debug, Copy, Clone, Default, Eq, PartialEq, Hash, Deserialize, Serialize, PartialOrd, Ord,
+)]
+pub struct L1Address(pub Felt);
+
+impl From<ContractAddress> for L1Address {
+    fn from(address: ContractAddress) -> Self {
+        L1Address(address.0.0)
+    }
+}
+
+impl TryFrom<L1Address> for ContractAddress {
+    type Error = StarknetApiError;
+
+    fn try_from(address: L1Address) -> Result<Self, Self::Error> {
+        Ok(ContractAddress(PatriciaKey::try_from(address.0)?))
+    }
+}
+
+impl From<EthAddress> for L1Address {
+    fn from(address: EthAddress) -> Self {
+        L1Address(address.into())
+    }
+}
+
+impl TryFrom<L1Address> for EthAddress {
+    type Error = StarknetApiError;
+
+    fn try_from(address: L1Address) -> Result<Self, Self::Error> {
+        EthAddress::try_from(address.0)
+    }
+}
+
+impl From<Felt> for L1Address {
+    fn from(felt: Felt) -> Self {
+        L1Address(felt)
+    }
+}
+
+impl From<L1Address> for Felt {
+    fn from(address: L1Address) -> Self {
+        address.0
+    }
+}
+
 impl TryFrom<Felt> for EthAddress {
     type Error = StarknetApiError;
     fn try_from(felt: Felt) -> Result<Self, Self::Error> {
