fix: settlement tests

Author: prkpndy

orchestrator/crates/settlement-clients/ethereum/src/conversion.rs

@@ -355,7 +355,7 @@ mod tests {
 
         let blob_data_vec = vec![hex_string_to_u8_vec(&blob_data).unwrap()];
 
-        match prepare_sidecar(&blob_data_vec, &trusted_setup, false) {
+        match prepare_sidecar(&blob_data_vec, &trusted_setup, true) {
             Ok(result) => {
                 match result {
                     BlobTransactionSidecarVariant::Eip4844(sidecar) => {

orchestrator/crates/settlement-clients/ethereum/src/lib.rs

@@ -154,7 +154,7 @@ impl EthereumSettlementClient {
             impersonate_account,
             max_gas_price_mul_factor: 2f64,
             tx_finality_retry_wait_in_seconds: 10,
-            disable_peerdas: false, // for testing, default to sepolia/testnet behavior
+            disable_peerdas: true,
         }
     }
 
@@ -571,10 +571,29 @@ mod test_config {
     #[allow(dead_code)]
     pub async fn configure_transaction(
         provider: Arc<DefaultHttpProvider>,
-        tx_envelope: TxEnvelope,
+        tx_envelope: Signed<TxEip4844Variant<BlobTransactionSidecarVariant>>,
         impersonate_account: Option<Address>,
     ) -> TransactionRequest {
-        let mut txn_request: TransactionRequest = tx_envelope.into();
+        // Extract the base transaction from the variant and convert to TransactionRequest
+        // For testing, we convert the variant to a standard TransactionRequest
+        let mut txn_request: TransactionRequest = match tx_envelope.tx() {
+            TxEip4844Variant::TxEip4844(_) => {
+                panic!("Wrong transaction type")
+            }
+            TxEip4844Variant::TxEip4844WithSidecar(tx_with_sidecar) => {
+                let sidecar = match &tx_with_sidecar.sidecar {
+                    BlobTransactionSidecarVariant::Eip4844(sidecar) => sidecar,
+                    BlobTransactionSidecarVariant::Eip7594(_) => {
+                        panic!("Wrong sidecar type")
+                    }
+                };
+                let tx = TxEip4844WithSidecar { tx: tx_with_sidecar.tx.clone(), sidecar: sidecar.clone() };
+                match tx_with_sidecar {
+                    &_ => {}
+                }
+                <TransactionRequest as From<TxEip4844WithSidecar>>::from(tx)
+            }
+        };
 
         // IMPORTANT to understand #[cfg(test)], #[cfg(not(test))] and SHOULD_IMPERSONATE_ACCOUNT
         // Two tests :  `update_state_blob_with_dummy_contract_works` &

orchestrator/crates/settlement-clients/ethereum/src/tests/mod.rs

@@ -2,10 +2,12 @@ use std::env;
 use std::path::PathBuf;
 use std::str::FromStr;
 
+use alloy::network::EthereumWallet;
 use alloy::node_bindings::{Anvil, AnvilInstance};
 use alloy::primitives::Address;
 use alloy::providers::ext::AnvilApi;
 use alloy::providers::ProviderBuilder;
+use alloy::signers::local::PrivateKeySigner;
 use alloy::sol;
 use orchestrator_utils::env_utils::get_env_var_or_panic;
 // Using the Pipe trait to write chained operations easier
@@ -67,6 +69,7 @@ pub struct EthereumTestBuilder {
 pub struct EthereumTest {
     _anvil: AnvilInstance,
     provider: crate::types::DefaultHttpProvider,
+    wallet_provider: crate::types::LocalWalletSignerMiddleware,
     pub rpc_url: Url,
 }
 
@@ -103,16 +106,24 @@ impl EthereumTestBuilder {
             None => Anvil::new().block_time(BLOCK_TIME).try_spawn().expect("Could not spawn Anvil."),
         };
 
-        // Setup Provider
+        // Setup wallet for the wallet_provider
+        let private_key = get_env_var_or_panic("MADARA_ORCHESTRATOR_ETHEREUM_PRIVATE_KEY");
+        let signer: PrivateKeySigner = private_key.parse().expect("Failed to parse private key");
+        let wallet = EthereumWallet::from(signer);
+
+        // Setup Provider without wallet (for general operations)
         let provider = ProviderBuilder::new().connect_http(anvil.endpoint_url());
 
+        // Setup Provider with wallet (for contract deployment and write operations)
+        let wallet_provider = ProviderBuilder::new().wallet(wallet).connect_http(anvil.endpoint_url());
+
         if let Some(impersonator) = self.impersonator {
             provider.anvil_impersonate_account(impersonator).await.expect("Unable to impersonate account.");
         }
 
         let rpc_url = anvil.endpoint_url();
 
-        EthereumTest { _anvil: anvil, provider, rpc_url }
+        EthereumTest { _anvil: anvil, provider, wallet_provider, rpc_url }
     }
 }
 
@@ -127,10 +138,9 @@ mod settlement_client_tests {
 
     use alloy::consensus::Transaction;
     use alloy::eips::eip4844::BYTES_PER_BLOB;
-    use alloy::primitives::Address;
+    use alloy::primitives::{Address, TxHash};
     use alloy::providers::Provider;
     use alloy::sol_types::private::U256;
-    use alloy_primitives::B256;
     use orchestrator_settlement_client_interface::{SettlementClient, SettlementVerificationStatus};
     use orchestrator_utils::env_utils::get_env_var_or_panic;
     use rstest::rstest;
@@ -204,11 +214,11 @@ mod settlement_client_tests {
             max_gas_price_mul_factor: get_env_var_or_panic("MADARA_ORCHESTRATOR_EIP1559_MAX_GAS_MUL_FACTOR")
                 .parse()
                 .expect("Invalid max gas price mul factor"),
-            disable_peerdas: false, // for tests, default to sepolia/testnet behavior
+            disable_peerdas: true,
         };
 
         // Deploying a dummy contract
-        let contract = DummyCoreContract::deploy(&setup.provider).await.expect("Unable to deploy address");
+        let contract = DummyCoreContract::deploy(&setup.wallet_provider).await.expect("Unable to deploy address");
         let ethereum_settlement_client = EthereumSettlementClient::with_test_params(
             setup.provider.clone(),
             *contract.address(),
@@ -237,7 +247,7 @@ mod settlement_client_tests {
 
         let txn = setup
             .provider
-            .get_transaction_by_hash(B256::from_str(update_state_result.as_str()).expect("Unable to convert txn"))
+            .get_transaction_by_hash(TxHash::from_str(update_state_result.as_str()).expect("Invalid tx hash"))
             .await
             .expect("did not get txn from hash")
             .unwrap();
@@ -341,7 +351,7 @@ mod settlement_client_tests {
         let latest_block_number = contract.stateBlockNumber().call().await.unwrap();
 
         let expected_latest_block_number = bytes_to_u32(program_output[3].as_slice()).unwrap();
-        assert_eq!(expected_latest_block_number, latest_block_number._0.as_u32());
+        assert_eq!(expected_latest_block_number, latest_block_number.as_u32());
     }
 
     #[rstest]

orchestrator/src/core/config.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "testing")]
-use alloy::providers::RootProvider;
+use alloy::providers::ProviderBuilder;
 
 use crate::utils::rest_client::RestClient;
 use anyhow::Context;
@@ -397,7 +397,7 @@ impl Config {
                 #[cfg(feature = "testing")]
                 {
                     Ok(Box::new(EthereumSettlementClient::with_test_params(
-                        RootProvider::new_http(ethereum_settlement_params.ethereum_rpc_url.clone()),
+                        ProviderBuilder::new().connect_http(ethereum_settlement_params.ethereum_rpc_url.clone()),
                         ethereum_settlement_params.l1_core_contract_address,
                         ethereum_settlement_params.ethereum_rpc_url.clone(),
                         Some(ethereum_settlement_params.starknet_operator_address),