test: Unify transaction flows and conversions in tests

Cargo.toml

@@ -20,6 +20,7 @@ members = [
     "supporting_crates/solidity_abi",
     "supporting_crates/solidity_abi_derive",
     "basic_system/src/system_implementation/ethereum_storage_model/supporting_crates/cc-traits",
+    "tests/common",
     "tests/rig",
     "tests/instances/transactions",
     "tests/instances/erc20",

api/src/helpers.rs

@@ -122,6 +122,8 @@ pub fn set_properties_code(account: &mut AccountProperties, evm_code: &[u8]) ->
 ///
 /// Internal tx encoding method.
 ///
+/// TODO: cleanup
+///
 #[allow(clippy::too_many_arguments)]
 pub fn encode_tx(
     tx_type: u8,

forward_system/src/run/convert.rs

@@ -1,7 +1,7 @@
+use crate::run::convert_alloy::{FromAlloy, IntoAlloy};
 use alloy::consensus::{Header, Sealed};
 use alloy::primitives::Log;
 use basic_bootloader::bootloader::block_header::BlockHeader;
-use ruint::aliases::B160;
 use zk_ee::common_structs::GenericEventContent;
 use zk_ee::system::metadata::zk_metadata::{BlockHashes, BlockMetadataFromOracle};
 use zk_ee::types_config::EthereumIOTypesConfig;
@@ -26,7 +26,7 @@ impl FromInterface<BlockContext> for BlockMetadataFromOracle {
             eip1559_basefee: value.eip1559_basefee,
             pubdata_price: value.pubdata_price,
             native_price: value.native_price,
-            coinbase: B160::from_be_bytes(value.coinbase.0 .0),
+            coinbase: ruint::aliases::B160::from_alloy(value.coinbase),
             gas_limit: value.gas_limit,
             pubdata_limit: value.pubdata_limit,
             mix_hash: value.mix_hash,
@@ -54,7 +54,7 @@ impl IntoInterface<InvalidTransaction>
             basic_bootloader::bootloader::errors::InvalidTransaction::NonceTooHigh { tx, state } => { InvalidTransaction::NonceTooHigh { tx, state } }
             basic_bootloader::bootloader::errors::InvalidTransaction::NonceTooLow { tx, state } => { InvalidTransaction::NonceTooLow { tx, state } }
             basic_bootloader::bootloader::errors::InvalidTransaction::MalleableSignature => { InvalidTransaction::MalleableSignature }
-            basic_bootloader::bootloader::errors::InvalidTransaction::IncorrectFrom { tx, recovered } => { InvalidTransaction::IncorrectFrom { tx: tx.to_be_bytes().into(), recovered: recovered.to_be_bytes().into() } }
+            basic_bootloader::bootloader::errors::InvalidTransaction::IncorrectFrom { tx, recovered } => { InvalidTransaction::IncorrectFrom { tx: tx.into_alloy(), recovered: recovered.into_alloy() } }
             basic_bootloader::bootloader::errors::InvalidTransaction::CreateInitCodeSizeLimit => { InvalidTransaction::CreateInitCodeSizeLimit }
             basic_bootloader::bootloader::errors::InvalidTransaction::InvalidChainId => { InvalidTransaction::InvalidChainId }
             basic_bootloader::bootloader::errors::InvalidTransaction::AccessListNotSupported => { InvalidTransaction::AccessListNotSupported }
@@ -90,8 +90,8 @@ impl IntoInterface<InvalidTransaction>
 impl IntoInterface<Log> for &GenericEventContent<4, EthereumIOTypesConfig> {
     fn into_interface(self) -> Log {
         Log::new(
-            self.address.to_be_bytes().into(),
-            self.topics.iter().map(|t| t.as_u8_array().into()).collect(),
+            self.address.into_alloy(),
+            self.topics.iter().map(|t| t.into_alloy()).collect(),
             self.data.as_slice().to_vec().into(),
         )
         .unwrap()
@@ -104,9 +104,9 @@ impl IntoInterface<L2ToL1Log> for zk_ee::common_structs::L2ToL1Log {
             l2_shard_id: self.l2_shard_id,
             is_service: self.is_service,
             tx_number_in_block: self.tx_number_in_block,
-            sender: self.sender.to_be_bytes().into(),
-            key: self.key.as_u8_array().into(),
-            value: self.value.as_u8_array().into(),
+            sender: self.sender.into_alloy(),
+            key: self.key.into_alloy(),
+            value: self.value.into_alloy(),
         }
     }
 }
@@ -115,20 +115,20 @@ impl IntoInterface<Sealed<Header>> for BlockHeader {
     fn into_interface(self) -> Sealed<Header> {
         let hash = self.hash();
         let header = Header {
-            parent_hash: self.parent_hash.as_u8_array().into(),
-            ommers_hash: self.ommers_hash.as_u8_array().into(),
-            beneficiary: self.beneficiary.to_be_bytes().into(),
-            state_root: self.state_root.as_u8_array().into(),
-            transactions_root: self.transactions_root.as_u8_array().into(),
-            receipts_root: self.receipts_root.as_u8_array().into(),
+            parent_hash: self.parent_hash.into_alloy(),
+            ommers_hash: self.ommers_hash.into_alloy(),
+            beneficiary: self.beneficiary.into_alloy(),
+            state_root: self.state_root.into_alloy(),
+            transactions_root: self.transactions_root.into_alloy(),
+            receipts_root: self.receipts_root.into_alloy(),
             logs_bloom: self.logs_bloom.into(),
             difficulty: self.difficulty,
             number: self.number,
             gas_limit: self.gas_limit,
             gas_used: self.gas_used,
             timestamp: self.timestamp,
             extra_data: self.extra_data.to_vec().into(),
-            mix_hash: self.mix_hash.as_u8_array().into(),
+            mix_hash: self.mix_hash.into_alloy(),
             nonce: self.nonce.into(),
             base_fee_per_gas: Some(self.base_fee_per_gas),
             withdrawals_root: None,

forward_system/src/run/convert_alloy.rs

@@ -0,0 +1,76 @@
+/// Generic conversion trait for converting values into Alloy primitives.
+pub trait IntoAlloy<T> {
+    /// Performs conversion into an Alloy type.
+    #[must_use]
+    fn into_alloy(self) -> T;
+}
+
+/// Generic conversion trait for converting values from Alloy primitives.
+pub trait FromAlloy<T> {
+    /// Performs conversion from an Alloy type.
+    #[must_use]
+    fn from_alloy(from: T) -> Self;
+}
+
+impl IntoAlloy<alloy::primitives::Address> for ruint::aliases::B160 {
+    #[inline]
+    fn into_alloy(self) -> alloy::primitives::Address {
+        alloy::primitives::Address::from(self.to_be_bytes())
+    }
+}
+
+impl IntoAlloy<alloy::primitives::Address> for &ruint::aliases::B160 {
+    #[inline]
+    fn into_alloy(self) -> alloy::primitives::Address {
+        alloy::primitives::Address::from(self.to_be_bytes())
+    }
+}
+
+impl FromAlloy<alloy::primitives::Address> for ruint::aliases::B160 {
+    #[inline]
+    fn from_alloy(from: alloy::primitives::Address) -> ruint::aliases::B160 {
+        ruint::aliases::B160::from_be_bytes(from.0.into())
+    }
+}
+
+impl FromAlloy<&alloy::primitives::Address> for ruint::aliases::B160 {
+    #[inline]
+    fn from_alloy(from: &alloy::primitives::Address) -> ruint::aliases::B160 {
+        ruint::aliases::B160::from_be_bytes(from.0.into())
+    }
+}
+
+impl IntoAlloy<alloy::primitives::B256> for zk_ee::utils::Bytes32 {
+    #[inline]
+    fn into_alloy(self) -> alloy::primitives::B256 {
+        alloy::primitives::B256::from(self.as_u8_array())
+    }
+}
+
+impl IntoAlloy<alloy::primitives::B256> for &zk_ee::utils::Bytes32 {
+    #[inline]
+    fn into_alloy(self) -> alloy::primitives::B256 {
+        alloy::primitives::B256::from(self.as_u8_array())
+    }
+}
+
+impl FromAlloy<alloy::primitives::B256> for zk_ee::utils::Bytes32 {
+    #[inline]
+    fn from_alloy(from: alloy::primitives::B256) -> zk_ee::utils::Bytes32 {
+        zk_ee::utils::Bytes32::from(from.0)
+    }
+}
+
+impl FromAlloy<&alloy::primitives::B256> for zk_ee::utils::Bytes32 {
+    #[inline]
+    fn from_alloy(from: &alloy::primitives::B256) -> zk_ee::utils::Bytes32 {
+        zk_ee::utils::Bytes32::from(from.0)
+    }
+}
+
+impl FromAlloy<&alloy::primitives::B256> for ruint::aliases::B256 {
+    #[inline]
+    fn from_alloy(from: &alloy::primitives::B256) -> ruint::aliases::B256 {
+        ruint::aliases::B256::from_be_bytes(from.0)
+    }
+}

forward_system/src/run/mod.rs

@@ -6,6 +6,7 @@ mod tx_result_callback;
 mod tx_source;
 
 pub mod convert;
+pub mod convert_alloy;
 mod interface_impl;
 pub mod query_processors;
 pub mod result_keeper;

forward_system/src/run/output.rs

@@ -1,6 +1,7 @@
 // Includes code adapted from https://github.com/bluealloy/revm/blob/fb80087996dfbd6c74eaf308538cfa707ecb763c/crates/context/interface/src/result.rs
 
 use crate::run::convert::IntoInterface;
+use crate::run::convert_alloy::IntoAlloy;
 use crate::run::result_keeper::ForwardRunningResultKeeper;
 use crate::run::TxResultCallback;
 use alloy::primitives::Address;
@@ -35,10 +36,10 @@ impl StorageWriteExt for StorageWrite {
     fn new(address: B160, key: Bytes32, value: Bytes32) -> StorageWrite {
         let flat_key = derive_flat_storage_key(&address, &key);
         StorageWrite {
-            key: flat_key.as_u8_array().into(),
-            value: value.as_u8_array().into(),
-            account: address.to_be_bytes().into(),
-            account_key: key.as_u8_array().into(),
+            key: flat_key.into_alloy(),
+            value: value.into_alloy(),
+            account: address.into_alloy(),
+            account_key: key.into_alloy(),
         }
     }
 }
@@ -131,7 +132,7 @@ impl<TR: TxResultCallback>
             .collect();
         let published_preimages = new_preimages
             .into_iter()
-            .map(|(hash, data, _)| (hash.as_u8_array().into(), data))
+            .map(|(hash, data, _)| (hash.into_alloy(), data))
             .collect();
 
         Self {
@@ -182,7 +183,7 @@ pub fn extract_account_diffs(
                     address: Address::from_slice(&key.as_u8_array_ref()[12..]),
                     nonce: properties.nonce,
                     balance: properties.balance,
-                    bytecode_hash: properties.bytecode_hash.as_u8_array().into(),
+                    bytecode_hash: properties.bytecode_hash.into_alloy(),
                 });
             } else {
                 unreachable!();

forward_system/src/run/preimage_source.rs

@@ -1,3 +1,4 @@
+use crate::run::convert_alloy::IntoAlloy;
 use zk_ee::utils::Bytes32;
 
 pub trait PreimageSource: 'static {
@@ -6,6 +7,6 @@ pub trait PreimageSource: 'static {
 
 impl<T: zksync_os_interface::traits::PreimageSource> PreimageSource for T {
     fn get_preimage(&mut self, hash: Bytes32) -> Option<Vec<u8>> {
-        self.get_preimage(hash.as_u8_array().into())
+        self.get_preimage(hash.into_alloy())
     }
 }

forward_system/src/run/query_processors/tx_data.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::run::convert_alloy::FromAlloy;
 use crate::run::NextTxResponse;
 use crate::run::TxSource;
 use basic_bootloader::bootloader::transaction::TxEncodingFormat;
@@ -80,7 +81,7 @@ impl<TS: TxSource, M: MemorySource> OracleQueryProcessor<M> for TxDataResponder<
                                 assert_ne!(next_tx_len, 0);
                                 self.next_tx = Some(next_tx);
                                 self.next_tx_format = Some(TxEncodingFormat::Rlp);
-                                self.next_tx_from = Some(B160::from_be_bytes(from.0 .0));
+                                self.next_tx_from = Some(B160::from_alloy(from));
                                 next_tx_len
                             }
                         }

forward_system/src/run/result_keeper.rs

@@ -1,3 +1,4 @@
+use crate::run::convert_alloy::IntoAlloy;
 use crate::run::TxResultCallback;
 use basic_bootloader::bootloader::result_keeper::{ResultKeeperExt, TxProcessingOutput};
 use ruint::aliases::B160;
@@ -104,7 +105,7 @@ impl<TR: TxResultCallback, T: 'static + Sized> ResultKeeperExt<EthereumIOTypesCo
         let owned_result = tx_result.map(|output| TxProcessingOutputOwned {
             status: output.status,
             output: output.output.to_vec(),
-            contract_address: output.contract_address.map(|a| a.to_be_bytes().into()),
+            contract_address: output.contract_address.map(IntoAlloy::into_alloy),
             gas_used: output.gas_used,
             gas_refunded: output.gas_refunded,
             computational_native_used: output.computational_native_used,

forward_system/src/run/tracing_impl.rs

@@ -1,3 +1,4 @@
+use crate::run::convert_alloy::IntoAlloy;
 use alloy::primitives::{Address, U256};
 use std::marker::PhantomData;
 use zk_ee::execution_environment_type::ExecutionEnvironmentType;
@@ -96,9 +97,9 @@ impl<'a, T: zksync_os_interface::tracing::EvmTracer, S: EthereumLikeTypes> Trace
     ) {
         self.0.on_storage_read(
             is_transient,
-            address.to_be_bytes().into(),
-            key.as_u8_array().into(),
-            value.as_u8_array().into(),
+            address.into_alloy(),
+            key.into_alloy(),
+            value.into_alloy(),
         )
     }
 
@@ -112,9 +113,9 @@ impl<'a, T: zksync_os_interface::tracing::EvmTracer, S: EthereumLikeTypes> Trace
     ) {
         self.0.on_storage_write(
             is_transient,
-            address.to_be_bytes().into(),
-            key.as_u8_array().into(),
-            value.as_u8_array().into(),
+            address.into_alloy(),
+            key.into_alloy(),
+            value.into_alloy(),
         )
     }
 
@@ -127,9 +128,9 @@ impl<'a, T: zksync_os_interface::tracing::EvmTracer, S: EthereumLikeTypes> Trace
         new_observable_bytecode_length: u32,
     ) {
         self.0.on_bytecode_change(
-            address.to_be_bytes().into(),
+            address.into_alloy(),
             new_raw_bytecode,
-            new_internal_bytecode_hash.as_u8_array().into(),
+            new_internal_bytecode_hash.into_alloy(),
             new_observable_bytecode_length,
         )
     }
@@ -142,11 +143,8 @@ impl<'a, T: zksync_os_interface::tracing::EvmTracer, S: EthereumLikeTypes> Trace
         data: &[u8],
     ) {
         self.0.on_event(
-            address.to_be_bytes().into(),
-            topics
-                .iter()
-                .map(|b| b.as_u8_array().into())
-                .collect::<Vec<_>>(),
+            (*address).into_alloy(),
+            topics.iter().map(|b| b.into_alloy()).collect::<Vec<_>>(),
             data,
         )
     }
@@ -201,7 +199,7 @@ impl<'a, T: zksync_os_interface::tracing::EvmTracer, S: EthereumLikeTypes> EvmTr
         frame_state: &impl EvmFrameInterface<S>,
     ) {
         self.0.on_selfdestruct(
-            beneficiary.to_be_bytes().into(),
+            beneficiary.into_alloy(),
             token_value,
             EvmFrameInterfaceWrapped::from(frame_state),
         )
@@ -224,11 +222,11 @@ impl<'a, 'b, S: EthereumLikeTypes> EvmRequest
     }
 
     fn caller(&self) -> Address {
-        self.0.external_call.caller.to_be_bytes().into()
+        self.0.external_call.caller.into_alloy()
     }
 
     fn callee(&self) -> Address {
-        self.0.external_call.callee.to_be_bytes().into()
+        self.0.external_call.callee.into_alloy()
     }
 
     fn modifier(&self) -> zksync_os_interface::tracing::CallModifier {
@@ -276,11 +274,11 @@ impl<'a, S: EthereumLikeTypes, T: EvmFrameInterface<S>>
     }
 
     fn caller(&self) -> Address {
-        self.inner.caller().to_be_bytes().into()
+        self.inner.caller().into_alloy()
     }
 
     fn address(&self) -> Address {
-        self.inner.address().to_be_bytes().into()
+        self.inner.address().into_alloy()
     }
 
     fn calldata(&self) -> &[u8] {

forward_system/src/run/tree.rs

@@ -1,3 +1,4 @@
+use crate::run::convert_alloy::{FromAlloy, IntoAlloy};
 use basic_system::system_implementation::flat_storage_model::LeafProof as GenericLeafProof;
 use basic_system::system_implementation::flat_storage_model::*;
 use zk_ee::utils::Bytes32;
@@ -19,7 +20,7 @@ pub trait ReadStorageTree: ReadStorage {
 
 impl<T: zksync_os_interface::traits::ReadStorage> ReadStorage for T {
     fn read(&mut self, key: Bytes32) -> Option<Bytes32> {
-        self.read(key.as_u8_array().into()).map(|v| v.0.into())
+        self.read(key.into_alloy()).map(Bytes32::from_alloy)
     }
 }
 

tests/common/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "zksync_os_tests_common"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+keywords.workspace = true
+categories.workspace = true
+
+[dependencies]
+alloy = { version = "1", default-features = false, features = [
+    "serde",
+    "serde-bincode-compat",
+] }
+ruint = { workspace = true, default-features = false }
+
+zksync_os_interface = { workspace = true, default-features = false }

tests/common/src/lib.rs

@@ -0,0 +1 @@
+pub mod zksync_tx;