Avoid modifying the SDK functions, restore it to the previous version

maximopalopoli · maximopalopoli · commit 1c0845ccee6d · 2025-06-24T11:37:40.000-03:00
diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
@@ -542,7 +542,7 @@ async fn main() -> Result<(), AlignedError> {
 
             let nonce = match &submit_args.nonce {
                 Some(nonce) => U256::from_dec_str(nonce).map_err(|_| SubmitError::InvalidNonce)?,
-                None => get_nonce_from_batcher(&used_network, wallet.address())
+                None => get_nonce_from_batcher(used_network.clone(), wallet.address())
                     .await
                     .map_err(|e| match e {
                         aligned_sdk::common::errors::GetNonceError::EthRpcError(e) => {
@@ -584,7 +584,7 @@ async fn main() -> Result<(), AlignedError> {
             info!("Submitting proofs to the Aligned batcher...");
 
             let aligned_verification_data_vec = submit_multiple(
-                &used_network,
+                used_network.clone(),
                 &verification_data_arr,
                 max_fee_wei,
                 wallet,
@@ -650,7 +650,7 @@ async fn main() -> Result<(), AlignedError> {
             info!("Verifying response data matches sent proof data...");
             let response = verification_layer::is_proof_verified(
                 &aligned_verification_data,
-                &(verify_inclusion_args.network.into()),
+                verify_inclusion_args.network.into(),
                 &verify_inclusion_args.eth_rpc_url,
             )
             .await?;
@@ -718,7 +718,7 @@ async fn main() -> Result<(), AlignedError> {
             let chain_id = get_chain_id(eth_rpc_url.as_str()).await?;
             wallet = wallet.with_chain_id(chain_id);
 
-            let client = SignerMiddleware::new(eth_rpc_provider, wallet.clone());
+            let client = SignerMiddleware::new(eth_rpc_provider, wallet);
 
             match deposit_to_aligned(amount_wei, client, deposit_to_batcher_args.network.into())
                 .await
@@ -758,7 +758,7 @@ async fn main() -> Result<(), AlignedError> {
         }
         GetUserNonce(args) => {
             let address = H160::from_str(&args.address).unwrap();
-            match get_nonce_from_batcher(&args.network.into(), address).await {
+            match get_nonce_from_batcher(args.network.into(), address).await {
                 Ok(nonce) => {
                     info!("Nonce for address {} is {}", address, nonce);
                 }
@@ -770,8 +770,7 @@ async fn main() -> Result<(), AlignedError> {
         }
         GetUserNonceFromEthereum(args) => {
             let address = H160::from_str(&args.address).unwrap();
-            let network = args.network.into();
-            match get_nonce_from_ethereum(&args.eth_rpc_url, address, &network).await {
+            match get_nonce_from_ethereum(&args.eth_rpc_url, address, args.network.into()).await {
                 Ok(nonce) => {
                     info!(
                         "Nonce for address {} in BatcherPaymentService contract is {}",
@@ -788,8 +787,8 @@ async fn main() -> Result<(), AlignedError> {
             let address = H160::from_str(&args.address).unwrap();
             let network: Network = args.network.into();
             let Ok((ethereum_nonce, batcher_nonce)) = future::try_join(
-                get_nonce_from_ethereum(&args.eth_rpc_url, address, &network),
-                get_nonce_from_batcher(&network, address),
+                get_nonce_from_ethereum(&args.eth_rpc_url, address, network.clone()),
+                get_nonce_from_batcher(network, address),
             )
             .await
             .map_err(|e| error!("Error while getting nonce: {:?}", e)) else {
diff --git a/crates/sdk/src/communication/batch.rs b/crates/sdk/src/communication/batch.rs
@@ -38,10 +38,10 @@ pub fn process_batcher_response(
 pub async fn await_batch_verification(
     aligned_verification_data: &AlignedVerificationData,
     rpc_url: &str,
-    network: &Network,
+    network: Network,
 ) -> Result<(), errors::SubmitError> {
     for _ in 0..RETRIES {
-        if is_proof_verified(aligned_verification_data, network, rpc_url)
+        if is_proof_verified(aligned_verification_data, network.clone(), rpc_url)
             .await
             .is_ok_and(|r| r)
         {
diff --git a/crates/sdk/src/verification_layer/mod.rs b/crates/sdk/src/verification_layer/mod.rs
@@ -82,21 +82,22 @@ use std::path::PathBuf;
 #[allow(clippy::too_many_arguments)] // TODO: Refactor this function, use NoncedVerificationData
 pub async fn submit_multiple_and_wait_verification(
     eth_rpc_url: &str,
-    network: &Network,
+    network: Network,
     verification_data: &[VerificationData],
     max_fee: U256,
     wallet: Wallet<SigningKey>,
     nonce: U256,
 ) -> Vec<Result<AlignedVerificationData, errors::SubmitError>> {
     let mut aligned_verification_data =
-        submit_multiple(network, verification_data, max_fee, wallet, nonce).await;
+        submit_multiple(network.clone(), verification_data, max_fee, wallet, nonce).await;
 
     // TODO: open issue: use a join to .await all at the same time, avoiding the loop
     // And await only once per batch, no need to await multiple proofs if they are in the same batch.
     let mut error_awaiting_batch_verification: Option<errors::SubmitError> = None;
     for aligned_verification_data_item in aligned_verification_data.iter().flatten() {
         if let Err(e) =
-            await_batch_verification(aligned_verification_data_item, eth_rpc_url, network).await
+            await_batch_verification(aligned_verification_data_item, eth_rpc_url, network.clone())
+                .await
         {
             error_awaiting_batch_verification = Some(e);
             break;
@@ -229,13 +230,13 @@ async fn fetch_gas_price(
 /// * `ProofQueueFlushed` if there is an error in the batcher and the proof queue is flushed.
 /// * `GenericError` if the error doesn't match any of the previous ones.
 pub async fn submit_multiple(
-    network: &Network,
+    network: Network,
     verification_data: &[VerificationData],
     max_fee: U256,
     wallet: Wallet<SigningKey>,
     nonce: U256,
 ) -> Vec<Result<AlignedVerificationData, errors::SubmitError>> {
-    let (ws_stream, _) = match connect_async(network.get_batcher_url()).await {
+    let (ws_stream, _) = match connect_async(network.clone().get_batcher_url()).await {
         Ok((ws_stream, response)) => (ws_stream, response),
         Err(e) => return vec![Err(errors::SubmitError::WebSocketConnectionError(e))],
     };
@@ -262,7 +263,7 @@ pub async fn submit_multiple(
 async fn _submit_multiple(
     ws_write: Arc<Mutex<SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>>>,
     mut ws_read: SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>,
-    network: &Network,
+    network: Network,
     verification_data: &[VerificationData],
     max_fee: U256,
     wallet: Wallet<SigningKey>,
@@ -350,7 +351,7 @@ async fn _submit_multiple(
 #[allow(clippy::too_many_arguments)] // TODO: Refactor this function, use NoncedVerificationData
 pub async fn submit_and_wait_verification(
     eth_rpc_url: &str,
-    network: &Network,
+    network: Network,
     verification_data: &VerificationData,
     max_fee: U256,
     wallet: Wallet<SigningKey>,
@@ -405,7 +406,7 @@ pub async fn submit_and_wait_verification(
 /// * `ProofQueueFlushed` if there is an error in the batcher and the proof queue is flushed.
 /// * `GenericError` if the error doesn't match any of the previous ones.
 pub async fn submit(
-    network: &Network,
+    network: Network,
     verification_data: &VerificationData,
     max_fee: U256,
     wallet: Wallet<SigningKey>,
@@ -441,7 +442,7 @@ pub async fn submit(
 /// * `HexDecodingError` if there is an error decoding the Aligned service manager contract address.
 pub async fn is_proof_verified(
     aligned_verification_data: &AlignedVerificationData,
-    network: &Network,
+    network: Network,
     eth_rpc_url: &str,
 ) -> Result<bool, errors::VerificationError> {
     let eth_rpc_provider =
@@ -454,10 +455,10 @@ pub async fn is_proof_verified(
 
 async fn _is_proof_verified(
     aligned_verification_data: &AlignedVerificationData,
-    network: &Network,
+    network: Network,
     eth_rpc_provider: Provider<Http>,
 ) -> Result<bool, errors::VerificationError> {
-    let contract_address = network.get_aligned_service_manager_address();
+    let contract_address = network.clone().get_aligned_service_manager_address();
     let payment_service_addr = network.get_batcher_payment_service_address();
 
     // All the elements from the merkle proof have to be concatenated
@@ -529,7 +530,7 @@ pub fn get_vk_commitment(
 /// # Errors
 /// * `EthRpcError` if the batcher has an error in the Ethereum call when retrieving the nonce if not already cached.
 pub async fn get_nonce_from_batcher(
-    network: &Network,
+    network: Network,
     address: Address,
 ) -> Result<U256, GetNonceError> {
     let (ws_stream, _) = connect_async(network.get_batcher_url())
@@ -605,7 +606,7 @@ pub async fn get_nonce_from_batcher(
 pub async fn get_nonce_from_ethereum(
     eth_rpc_url: &str,
     submitter_addr: Address,
-    network: &Network,
+    network: Network,
 ) -> Result<U256, GetNonceError> {
     let eth_rpc_provider = Provider::<Http>::try_from(eth_rpc_url)
         .map_err(|e| GetNonceError::EthRpcError(e.to_string()))?;
diff --git a/crates/task-sender/src/commands.rs b/crates/task-sender/src/commands.rs
@@ -318,17 +318,17 @@ pub async fn send_infinite_proofs(args: SendInfiniteProofsArgs) {
     let network: Network = args.network.into();
     info!("Starting senders!");
     for (i, sender) in senders.iter().enumerate() {
+        // this clones are necessary because of the move
         let wallet = sender.wallet.clone();
         let verification_data = verification_data.clone();
-        // this is necessary because of the move
         let network_clone = network.clone();
 
         // a thread to send tasks from each loaded wallet:
         let handle = tokio::spawn(async move {
             loop {
                 let n = network_clone.clone();
                 let mut result = Vec::with_capacity(args.burst_size);
-                let nonce = get_nonce_from_batcher(&n, wallet.address())
+                let nonce = get_nonce_from_batcher(n.clone(), wallet.address())
                     .await
                     .inspect_err(|e| {
                         error!(
@@ -347,11 +347,11 @@ pub async fn send_infinite_proofs(args: SendInfiniteProofsArgs) {
 
                 info!(
                     "Sending {:?} Proofs to Aligned Batcher on {:?} from sender {}, nonce: {}, address: {:?}",
-                    args.burst_size, n.clone(), i, nonce, wallet.address(),
+                    args.burst_size, n, i, nonce, wallet.address(),
                 );
 
                 let aligned_verification_data = submit_multiple(
-                    &n,
+                    n,
                     &verification_data_to_send.clone(),
                     max_fee,
                     wallet.clone(),
