feat: add fund_payment_service and get_balance_in_payment_sevice on sdk (#1142)

Author: uri-99

batcher/aligned-sdk/src/core/errors.rs

@@ -306,3 +306,16 @@ impl fmt::Display for VerifySignatureError {
         }
     }
 }
+
+#[derive(Debug)]
+pub enum PaymentError {
+    SendError(String),
+    SubmitError(String),
+    PaymentFailed,
+}
+
+#[derive(Debug)]
+pub enum BalanceError {
+    EthereumProviderError(String),
+    EthereumCallError(String),
+}

batcher/aligned-sdk/src/sdk.rs

@@ -22,9 +22,11 @@ use crate::{
 };
 
 use ethers::{
+    core::types::TransactionRequest,
+    middleware::SignerMiddleware,
     prelude::k256::ecdsa::SigningKey,
     providers::{Http, Middleware, Provider},
-    signers::Wallet,
+    signers::{LocalWallet, Wallet},
     types::{Address, H160, U256},
 };
 use sha3::{Digest, Keccak256};
@@ -582,6 +584,77 @@ pub async fn get_chain_id(eth_rpc_url: &str) -> Result<u64, errors::ChainIdError
     Ok(chain_id.as_u64())
 }
 
+/// Funds the batcher payment service in name of the signer
+/// # Arguments
+/// * `amount` - The amount to be paid.
+/// * `signer` - The signer middleware of the payer.
+/// * `network` - The network on which the payment will be done.
+/// # Returns
+/// * The receipt of the payment transaction.
+/// # Errors
+/// * `SendError` if there is an error sending the transaction.
+/// * `SubmitError` if there is an error submitting the transaction.
+/// * `PaymentFailed` if the payment failed.
+pub async fn deposit_to_aligned(
+    amount: U256,
+    signer: SignerMiddleware<Provider<Http>, LocalWallet>,
+    network: Network,
+) -> Result<ethers::types::TransactionReceipt, errors::PaymentError> {
+    let payment_service_address = get_payment_service_address(network);
+    let from = signer.address();
+
+    let tx = TransactionRequest::new()
+        .from(from)
+        .to(payment_service_address)
+        .value(amount);
+
+    match signer
+        .send_transaction(tx, None)
+        .await
+        .map_err(|e| errors::PaymentError::SendError(e.to_string()))?
+        .await
+        .map_err(|e| errors::PaymentError::SubmitError(e.to_string()))?
+    {
+        Some(receipt) => Ok(receipt),
+        None => Err(errors::PaymentError::PaymentFailed),
+    }
+}
+
+/// Returns the balance of a user in the payment service.
+/// # Arguments
+/// * `user` - The address of the user.
+/// * `eth_rpc_url` - The URL of the Ethereum RPC node.
+/// * `network` - The network on which the balance will be checked.
+/// # Returns
+/// * The balance of the user in the payment service.
+/// # Errors
+/// * `EthereumProviderError` if there is an error in the connection with the RPC provider.
+/// * `EthereumCallError` if there is an error in the Ethereum call.
+pub async fn get_balance_in_aligned(
+    user: Address,
+    eth_rpc_url: &str,
+    network: Network,
+) -> Result<U256, errors::BalanceError> {
+    let eth_rpc_provider = Provider::<Http>::try_from(eth_rpc_url)
+        .map_err(|e| errors::BalanceError::EthereumProviderError(e.to_string()))?;
+
+    let payment_service_address = get_payment_service_address(network);
+
+    match batcher_payment_service(eth_rpc_provider, payment_service_address).await {
+        Ok(batcher_payment_service) => {
+            let call = batcher_payment_service.user_balances(user);
+
+            let result = call
+                .call()
+                .await
+                .map_err(|e| errors::BalanceError::EthereumCallError(e.to_string()))?;
+
+            Ok(result)
+        }
+        Err(e) => Err(errors::BalanceError::EthereumCallError(e.to_string())),
+    }
+}
+
 #[cfg(test)]
 mod test {
     //Public constants for convenience

batcher/aligned/src/main.rs

@@ -14,7 +14,7 @@ use aligned_sdk::core::{
 };
 use aligned_sdk::sdk::get_chain_id;
 use aligned_sdk::sdk::get_next_nonce;
-use aligned_sdk::sdk::get_payment_service_address;
+use aligned_sdk::sdk::{deposit_to_aligned, get_balance_in_aligned};
 use aligned_sdk::sdk::{get_vk_commitment, is_proof_verified, submit_multiple};
 use clap::Parser;
 use clap::Subcommand;
@@ -418,6 +418,10 @@ async fn main() -> Result<(), AlignedError> {
 
             let amount = deposit_to_batcher_args.amount.replace("ether", "");
 
+            let amount_ether = parse_ether(&amount).map_err(|e| {
+                SubmitError::EthereumProviderError(format!("Error while parsing amount: {}", e))
+            })?;
+
             let eth_rpc_url = deposit_to_batcher_args.eth_rpc_url;
 
             let eth_rpc_provider =
@@ -445,99 +449,41 @@ async fn main() -> Result<(), AlignedError> {
 
             let client = SignerMiddleware::new(eth_rpc_provider.clone(), wallet.clone());
 
-            let balance = client
-                .get_balance(wallet.address(), None)
+            match deposit_to_aligned(amount_ether, client, deposit_to_batcher_args.network.into())
                 .await
-                .map_err(|e| {
-                    SubmitError::EthereumProviderError(format!(
-                        "Error while getting balance: {}",
-                        e
-                    ))
-                })?;
-
-            let amount_ether = parse_ether(&amount).map_err(|e| {
-                SubmitError::EthereumProviderError(format!("Error while parsing amount: {}", e))
-            })?;
-
-            if amount_ether <= U256::from(0) {
-                error!("Amount should be greater than 0");
-                return Ok(());
-            }
-
-            if balance < amount_ether {
-                error!("Insufficient funds to pay to the batcher. Please deposit some Ether in your wallet.");
-                return Ok(());
-            }
-
-            let batcher_addr = get_payment_service_address(deposit_to_batcher_args.network.into());
-
-            let tx = TransactionRequest::new()
-                .to(batcher_addr)
-                .value(amount_ether)
-                .from(wallet.address());
-
-            info!("Sending {} ether to the batcher", amount);
-
-            let tx = client
-                .send_transaction(tx, None)
-                .await
-                .map_err(|e| {
-                    SubmitError::EthereumProviderError(format!(
-                        "Error while sending transaction: {}",
-                        e
-                    ))
-                })?
-                .await
-                .map_err(|e| {
-                    SubmitError::EthereumProviderError(format!(
-                        "Error while sending transaction: {}",
-                        e
-                    ))
-                })?;
-
-            if let Some(tx) = tx {
-                info!(
-                    "Payment sent to the batcher successfully. Tx: 0x{:x}",
-                    tx.transaction_hash
-                );
-            } else {
-                error!("Transaction failed");
+            {
+                Ok(receipt) => {
+                    info!(
+                        "Payment sent to the batcher successfully. Tx: 0x{:x}",
+                        receipt.transaction_hash
+                    );
+                }
+                Err(e) => {
+                    error!("Transaction failed: {:?}", e);
+                }
             }
         }
         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::EthereumProviderError(format!(
-                    "Error while connecting to Ethereum: {}",
-                    e
-                ))
-            })?;
-
-            let user_address =
-                Address::from_str(&get_user_balance_args.user_address).map_err(|e| {
-                    SubmitError::HexDecodingError(format!(
-                        "Error while parsing user address: {}",
-                        e
-                    ))
-                })?;
-
-            let batcher_addr = get_payment_service_address(get_user_balance_args.network.into());
-
-            let balance = get_user_balance(eth_rpc_provider, batcher_addr, user_address)
-                .await
-                .map_err(|e| {
-                    SubmitError::EthereumProviderError(format!(
-                        "Error while getting user balance: {}",
-                        e
-                    ))
-                })?;
-
-            info!(
-                "User {} has {} ether in the batcher",
+            let user_address = H160::from_str(&get_user_balance_args.user_address).unwrap();
+            match get_balance_in_aligned(
                 user_address,
-                format_ether(balance)
-            );
+                &get_user_balance_args.eth_rpc_url,
+                get_user_balance_args.network.into(),
+            )
+            .await
+            {
+                Ok(balance) => {
+                    info!(
+                        "User {} has {} ether in the batcher",
+                        user_address,
+                        format_ether(balance)
+                    );
+                }
+                Err(e) => {
+                    error!("Error while getting user balance: {:?}", e);
+                    return Ok(());
+                }
+            }
         }
     }