feat: pay to batcher with keystore (#514)

Co-authored-by: Mariano Nicolini <mariano.nicolini.91@gmail.com>
Co-authored-by: Santos Rosati <rosatisantos@gmail.com>
Co-authored-by: Urix <43704209+uri-99@users.noreply.github.com>
Co-authored-by: JuArce <52429267+JuArce@users.noreply.github.com>
Co-authored-by: MauroFab <maurotoscano2@gmail.com>

Author: 6 people

README_SEND_PROOFS.md

@@ -35,7 +35,30 @@ This will create the ECDSA keystore file in `~/.aligned_keystore/keystore0`
 
 - If you have the EigenLayer CLI installed, the keystore can be generated following [this](https://docs.eigenlayer.xyz/eigenlayer/operator-guides/operator-installation#import-keys) instructions. The key will be stored into `~/.eigenlayer/operator_keys`.
 
-## SP1 proof
+## 2. Fund the batcher
+
+To be able to send proofs to Aligned using the batcher, the user must fund its transactions. For this, there is a simple Batcher Payment System.
+
+To use it you can use the `aligned` CLI, as shown with the following example:
+
+```bash
+aligned deposit-to-batcher --keystore_path <keystore_path> --amount 0.1ether
+```
+
+This commands also allows the usage of the flags: 
+- `--batcher_addr` to specify the address of the Batcher Payment Service smart contract.
+- `--rpc` to specify the rpc url to be used.
+- `--chain` to specify the chain id to be used.
+- 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>
+```
+
+## 3. Send your proof to the batcher
+
+### SP1 proof
 
 The SP1 proof needs the proof file and the vm program file.
 
@@ -63,7 +86,7 @@ aligned submit \
 --keystore_path ~/.aligned_keystore/keystore0
 ```
 
-## Risc0 proof
+### Risc0 proof
 
 The Risc0 proof needs the proof file and the vm program file (vm program file is the image id).
 
@@ -91,7 +114,7 @@ aligned submit \
 --keystore_path ~/.aligned_keystore/keystore0
 ```
 
-## GnarkPlonkBn254, GnarkPlonkBls12_381 and Groth16Bn254
+### GnarkPlonkBn254, GnarkPlonkBls12_381 and Groth16Bn254
 
 The GnarkPlonkBn254, GnarkPlonkBls12_381 and Groth16Bn254 proofs need the proof file, the public input file and the verification key file.
 

batcher/aligned/src/main.rs

@@ -7,6 +7,7 @@ use std::str::FromStr;
 
 use aligned_sdk::errors::{AlignedError, SubmitError};
 use aligned_sdk::types::AlignedVerificationData;
+use aligned_sdk::types::Chain;
 use aligned_sdk::types::ProvingSystemId;
 use aligned_sdk::types::VerificationData;
 use clap::Parser;
@@ -20,7 +21,9 @@ use log::{error, info};
 use aligned_sdk::sdk::{get_verification_key_commitment, submit_multiple, verify_proof_onchain};
 
 use ethers::utils::hex;
+use ethers::utils::parse_ether;
 
+use crate::AlignedCommands::DepositToBatcher;
 use crate::AlignedCommands::GetVerificationKeyCommitment;
 use crate::AlignedCommands::Submit;
 use crate::AlignedCommands::VerifyProofOnchain;
@@ -45,6 +48,12 @@ pub enum AlignedCommands {
         name = "get-vk-commitment"
     )]
     GetVerificationKeyCommitment(GetVerificationKeyCommitmentArgs),
+    // GetVericiationKey, command name is get-vk-commitment
+    #[clap(
+        about = "Deposits Ethereum in the batcher to pay for proofs",
+        name = "deposit-to-batcher"
+    )]
+    DepositToBatcher(DepositToBatcherArgs),
 }
 
 #[derive(Parser, Debug)]
@@ -90,6 +99,37 @@ pub struct SubmitArgs {
     private_key: Option<String>,
 }
 
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+pub struct DepositToBatcherArgs {
+    #[arg(
+        name = "Batcher Eth Address",
+        long = "batcher_addr",
+        default_value = "0x7969c5eD335650692Bc04293B07F5BF2e7A673C0"
+    )]
+    batcher_eth_address: String,
+    #[arg(
+        name = "Path to local keystore",
+        long = "keystore_path",
+        required = true
+    )]
+    keystore_path: Option<PathBuf>,
+    #[arg(
+        name = "Ethereum RPC provider address",
+        long = "rpc",
+        default_value = "http://localhost:8545"
+    )]
+    eth_rpc_url: String,
+    #[arg(
+        name = "The Ethereum network's name",
+        long = "chain",
+        default_value = "devnet"
+    )]
+    chain: ChainArg,
+    #[arg(name = "Amount to deposit", long = "amount", required = true)]
+    amount: String,
+}
+
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
 pub struct VerifyProofOnchainArgs {
@@ -283,6 +323,93 @@ async fn main() -> Result<(), AlignedError> {
                     .map_err(|e| SubmitError::IoError(output_file.clone(), e))?;
             }
         }
+        DepositToBatcher(deposit_to_batcher_args) => {
+            if !deposit_to_batcher_args.amount.ends_with("ether") {
+                error!("Amount should be in the format XX.XXether");
+                return Ok(());
+            }
+
+            let chain: aligned_sdk::types::Chain = deposit_to_batcher_args.chain.into();
+
+            let amount = deposit_to_batcher_args.amount.replace("ether", "");
+
+            let eth_rpc_url = deposit_to_batcher_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 keystore_path = &deposit_to_batcher_args.keystore_path;
+
+            let mut wallet = if let Some(keystore_path) = keystore_path {
+                let password = rpassword::prompt_password("Please enter your keystore password:")
+                    .map_err(|e| SubmitError::GenericError(e.to_string()))?;
+                Wallet::decrypt_keystore(keystore_path, password)
+                    .map_err(|e| SubmitError::GenericError(e.to_string()))?
+            } else {
+                warn!("Missing keystore used for payment.");
+                return Ok(());
+            };
+
+            match chain {
+                Chain::Devnet => wallet = wallet.with_chain_id(31337u64),
+                Chain::Holesky => wallet = wallet.with_chain_id(17000u64),
+            }
+
+            let client = SignerMiddleware::new(eth_rpc_provider.clone(), wallet.clone());
+
+            let balance = client
+                .get_balance(wallet.address(), None)
+                .await
+                .map_err(|e| {
+                    SubmitError::EthError(format!("Error while getting balance: {}", e))
+                })?;
+
+            let amount_ether = parse_ether(&amount)
+                .map_err(|e| SubmitError::EthError(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 = Address::from_str(&deposit_to_batcher_args.batcher_eth_address)
+                .map_err(|e| {
+                    SubmitError::EthError(format!("Error while parsing batcher address: {}", e))
+                })?;
+
+            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::EthError(format!("Error while sending transaction: {}", e))
+                })?
+                .await
+                .map_err(|e| {
+                    SubmitError::EthError(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(())