feat: add get user balance cli command (#547)

Author: NicolasRampoldi

README_SEND_PROOFS.md

@@ -52,8 +52,9 @@ This commands also allows the usage of the flags:
 - Note: `--amount` flag parameter must be with the shown format, followed by the `ether` keyword to specify how many ethers you wish to deposit to the batcher.
 
 After depositing funds, you can verify the Service has correctly received them, executing the following command:
+
 ```bash
-cast call <payment_service_smart_contract_address> "UserBalances(address)(uint256)" <address>
+aligned get-user-balance --user_addr <user_addr>
 ```
 
 ## 3. Send your proof to the batcher

batcher/aligned/src/main.rs

@@ -20,10 +20,13 @@ use log::{error, info};
 
 use aligned_sdk::sdk::{get_verification_key_commitment, submit_multiple, verify_proof_onchain};
 
+use ethers::utils::format_ether;
 use ethers::utils::hex;
 use ethers::utils::parse_ether;
+use transaction::eip2718::TypedTransaction;
 
 use crate::AlignedCommands::DepositToBatcher;
+use crate::AlignedCommands::GetUserBalance;
 use crate::AlignedCommands::GetVerificationKeyCommitment;
 use crate::AlignedCommands::Submit;
 use crate::AlignedCommands::VerifyProofOnchain;
@@ -54,6 +57,8 @@ pub enum AlignedCommands {
         name = "deposit-to-batcher"
     )]
     DepositToBatcher(DepositToBatcherArgs),
+    #[clap(about = "Get user balance from the batcher", name = "get-user-balance")]
+    GetUserBalance(GetUserBalanceArgs),
 }
 
 #[derive(Parser, Debug)]
@@ -158,6 +163,29 @@ pub struct GetVerificationKeyCommitmentArgs {
     output_file: Option<PathBuf>,
 }
 
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+pub struct GetUserBalanceArgs {
+    #[arg(
+        name = "Batcher Eth Address",
+        long = "batcher_addr",
+        default_value = "0x7969c5eD335650692Bc04293B07F5BF2e7A673C0"
+    )]
+    batcher_eth_address: String,
+    #[arg(
+        name = "Ethereum RPC provider address",
+        long = "rpc",
+        default_value = "http://localhost:8545"
+    )]
+    eth_rpc_url: String,
+    #[arg(
+        name = "The user's Ethereum address",
+        long = "user_addr",
+        required = true
+    )]
+    user_address: String,
+}
+
 #[derive(Debug, Clone, ValueEnum)]
 enum ChainArg {
     Devnet,
@@ -410,6 +438,35 @@ async fn main() -> Result<(), AlignedError> {
                 error!("Transaction failed");
             }
         }
+        GetUserBalance(get_user_balance_args) => {
+            let eth_rpc_url = get_user_balance_args.eth_rpc_url;
+
+            let eth_rpc_provider = Provider::<Http>::try_from(eth_rpc_url).map_err(|e| {
+                SubmitError::EthError(format!("Error while connecting to Ethereum: {}", e))
+            })?;
+
+            let user_address =
+                Address::from_str(&get_user_balance_args.user_address).map_err(|e| {
+                    SubmitError::EthError(format!("Error while parsing user address: {}", e))
+                })?;
+
+            let batcher_addr = Address::from_str(&get_user_balance_args.batcher_eth_address)
+                .map_err(|e| {
+                    SubmitError::EthError(format!("Error while parsing batcher address: {}", e))
+                })?;
+
+            let balance = get_user_balance(eth_rpc_provider, batcher_addr, user_address)
+                .await
+                .map_err(|e| {
+                    SubmitError::EthError(format!("Error while getting user balance: {}", e))
+                })?;
+
+            info!(
+                "User {} has {} ether in the batcher",
+                user_address,
+                format_ether(balance)
+            );
+        }
     }
 
     Ok(())
@@ -494,3 +551,33 @@ fn save_response(
 
     Ok(())
 }
+
+pub async fn get_user_balance(
+    provider: Provider<Http>,
+    contract_address: Address,
+    user_address: Address,
+) -> Result<U256, ProviderError> {
+    let selector = &ethers::utils::keccak256("UserBalances(address)".as_bytes())[..4];
+
+    let encoded_params = ethers::abi::encode(&[ethers::abi::Token::Address(user_address)]);
+
+    let mut call_data = selector.to_vec();
+    call_data.extend_from_slice(&encoded_params);
+
+    let tx = TypedTransaction::Legacy(TransactionRequest {
+        to: Some(NameOrAddress::Address(contract_address)),
+        data: Some(Bytes(call_data.into())),
+        ..Default::default()
+    });
+
+    let result = provider.call_raw(&tx).await?;
+
+    if result.len() == 32 {
+        let balance = U256::from_big_endian(&result);
+        Ok(balance)
+    } else {
+        Err(ProviderError::CustomError(
+            "Invalid response from contract".to_string(),
+        ))
+    }
+}