feat(cli): add get-user-first-nonce + get-user-number-queued-proofs cli commands

batcher/aligned/src/main.rs

@@ -12,6 +12,7 @@ use aligned_sdk::core::{
 };
 use aligned_sdk::sdk::get_chain_id;
 use aligned_sdk::sdk::get_nonce_from_batcher;
+use aligned_sdk::sdk::get_nonce_from_ethereum;
 use aligned_sdk::sdk::{deposit_to_aligned, get_balance_in_aligned};
 use aligned_sdk::sdk::{get_vk_commitment, is_proof_verified, save_response, submit_multiple};
 use clap::Parser;
@@ -27,8 +28,10 @@ use log::{error, info};
 use transaction::eip2718::TypedTransaction;
 
 use crate::AlignedCommands::DepositToBatcher;
+use crate::AlignedCommands::GetAmountOfProofsInBatcherQueue;
 use crate::AlignedCommands::GetUserBalance;
 use crate::AlignedCommands::GetUserNonce;
+use crate::AlignedCommands::GetUserNonceFromEthereum;
 use crate::AlignedCommands::GetVkCommitment;
 use crate::AlignedCommands::Submit;
 use crate::AlignedCommands::VerifyProofOnchain;
@@ -56,8 +59,21 @@ pub enum AlignedCommands {
     DepositToBatcher(DepositToBatcherArgs),
     #[clap(about = "Get user balance from the batcher", name = "get-user-balance")]
     GetUserBalance(GetUserBalanceArgs),
-    #[clap(about = "Get user nonce from the batcher", name = "get-user-nonce")]
+    #[clap(
+        about = "Gets user current nonce from the batcher. This is the nonce you should send in your next proof.",
+        name = "get-user-nonce"
+    )]
     GetUserNonce(GetUserNonceArgs),
+    #[clap(
+        about = "Gets the user nonce directly from the BatcherPaymentService contract. Useful for validating the on-chain state and check if your transactions are pending in the batcher.",
+        name = "get-user-nonce-from-ethereum"
+    )]
+    GetUserNonceFromEthereum(GetUserNonceFromEthereumArgs),
+    #[clap(
+        about = "Gets the amount of proofs a user has queued in the Batcher.",
+        name = "get-amount-of-proofs-in-batcher-queue"
+    )]
+    GetAmountOfProofsInBatcherQueue(GetAmountOfProofsInBatcherQueueArgs),
 }
 
 #[derive(Parser, Debug)]
@@ -218,6 +234,58 @@ pub struct GetUserNonceArgs {
     address: String,
 }
 
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+pub struct GetUserNonceFromEthereumArgs {
+    #[arg(
+        name = "Ethereum RPC provider address",
+        long = "rpc_url",
+        default_value = "http://localhost:8545"
+    )]
+    eth_rpc_url: String,
+    #[arg(
+        name = "The user's Ethereum address",
+        long = "user_addr",
+        required = true
+    )]
+    address: String,
+    #[arg(
+        name = "The working network's name",
+        long = "network",
+        default_value = "devnet"
+    )]
+    network: NetworkArg,
+}
+
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+pub struct GetAmountOfProofsInBatcherQueueArgs {
+    #[arg(
+        name = "Ethereum RPC provider address",
+        long = "rpc_url",
+        default_value = "http://localhost:8545"
+    )]
+    eth_rpc_url: String,
+    #[arg(
+        name = "The user's Ethereum address",
+        long = "user_addr",
+        required = true
+    )]
+    address: String,
+    #[arg(
+        name = "The working network's name",
+        long = "network",
+        default_value = "devnet"
+    )]
+    network: NetworkArg,
+    #[arg(
+        name = "Batcher connection address",
+        long = "batcher_url",
+        default_value = "ws://localhost:8080"
+    )]
+    batcher_url: String,
+}
+
 #[derive(Debug, Clone, ValueEnum, Copy)]
 enum NetworkArg {
     Devnet,
@@ -528,6 +596,51 @@ 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 {
+                Ok(nonce) => {
+                    info!(
+                        "Nonce for address {} in BatcherPaymentService contract is {}",
+                        address, nonce
+                    );
+                }
+                Err(e) => {
+                    error!("Error while getting nonce: {:?}", e);
+                    return Ok(());
+                }
+            }
+        }
+        GetAmountOfProofsInBatcherQueue(args) => {
+            let address = H160::from_str(&args.address).unwrap();
+            let network = args.network.into();
+            let ethereum_nonce =
+                match get_nonce_from_ethereum(&args.eth_rpc_url, address, network).await {
+                    Ok(nonce) => nonce,
+                    Err(e) => {
+                        error!("Error while getting nonce: {:?}", e);
+                        return Ok(());
+                    }
+                };
+            let batcher_nonce = match get_nonce_from_batcher(&args.batcher_url, address).await {
+                Ok(nonce) => nonce,
+                Err(e) => {
+                    error!("Error while getting nonce: {:?}", e);
+                    return Ok(());
+                }
+            };
+            if ethereum_nonce > batcher_nonce {
+                error!("User {} is in an invalid state.", address);
+            } else {
+                info!(
+                    "User {} has {} proofs in the batcher queue",
+                    address,
+                    batcher_nonce - ethereum_nonce
+                );
+            }
+            return Ok(());
+        }
     }
 
     Ok(())