feat(l2): withdrawal handling (#877)

**Motivation**

<!-- Why does this pull request exist? What are its goals? -->
Withdrawals are an essential requirement for L2 networks.

**Description**

<!-- A clear and concise general description of the changes this PR
introduces -->
We introduce a new EIP-2718 transaction type called
`PrivilegedL2Transaction` used to manage deposits and withdraws.
Handlers were set to the VM so when this transactions get executed, it
runs custom logic like minting or burning ETH.
Different CLI commands were also introduced to easily create and send
this transactions.

<!-- Link to issues: Resolves #111, Resolves #222 -->

Closes #816
Closes #839

---------

Co-authored-by: ilitteri <ilitteri@fi.uba.ar>
Co-authored-by: Ivan Litteri <67517699+ilitteri@users.noreply.github.com>

Author: ManuelBilbao

cmd/ethereum_rust_l2/Cargo.toml

@@ -33,5 +33,5 @@ ethereum_rust-prover.workspace = true
 ethereum_rust-rlp.workspace = true
 
 [[bin]]
-name = "ethereum_rust_l2"
+name = "l2"
 path = "./src/main.rs"

cmd/ethereum_rust_l2/src/commands/utils.rs

@@ -3,6 +3,7 @@ use std::str::FromStr;
 use bytes::Bytes;
 use clap::Subcommand;
 use ethereum_types::{Address, H32, U256};
+use eyre::eyre;
 use keccak_hash::{keccak, H256};
 
 #[derive(Subcommand)]
@@ -69,49 +70,65 @@ fn parse_arg(arg_type: &str, arg: &str) -> Vec<u8> {
 
 fn parse_vec_arg(arg_type: &str, arg: &str) -> Vec<u8> {
     let args = arg.split(',');
+    let length = &mut [0u8; 32];
+    U256::from(args.clone().count()).to_big_endian(length);
+    let length = length.to_vec();
+
     match arg_type {
         "address[]" => {
-            return args
-                .map(|arg| {
+            return [
+                length,
+                args.map(|arg| {
                     H256::from(Address::from_str(arg).expect("Cannot parse address[]"))
                         .0
                         .to_vec()
                 })
                 .collect::<Vec<Vec<u8>>>()
-                .concat();
+                .concat(),
+            ]
+            .concat();
         }
         "uint8[]" => {
-            return args
-                .map(|arg| {
+            return [
+                length,
+                args.map(|arg| {
                     let buf: &mut [u8] = &mut [0u8; 32];
                     U256::from(u8::from_str(arg).expect("Cannot parse u8[]")).to_big_endian(buf);
                     buf.to_vec()
                 })
                 .collect::<Vec<Vec<u8>>>()
-                .concat();
+                .concat(),
+            ]
+            .concat();
         }
         "uint256[]" => {
-            return args
-                .map(|arg| {
+            return [
+                length,
+                args.map(|arg| {
                     let buf: &mut [u8] = &mut [0u8; 32];
                     U256::from_dec_str(arg)
                         .expect("Cannot parse u256[]")
                         .to_big_endian(buf);
                     buf.to_vec()
                 })
                 .collect::<Vec<Vec<u8>>>()
-                .concat();
+                .concat(),
+            ]
+            .concat();
         }
         "bytes32[]" => {
-            return args
-                .map(|arg| {
+            return [
+                length,
+                args.map(|arg| {
                     H256::from_str(arg)
                         .expect("Cannot parse bytes32[]")
                         .0
                         .to_vec()
                 })
                 .collect::<Vec<Vec<u8>>>()
-                .concat();
+                .concat(),
+            ]
+            .concat();
         }
         _ => {
             println!("Unsupported type: {arg_type}");
@@ -120,6 +137,48 @@ fn parse_vec_arg(arg_type: &str, arg: &str) -> Vec<u8> {
     vec![]
 }
 
+pub fn encode_calldata(
+    signature: &str,
+    args: &str,
+    only_args: bool,
+) -> Result<Vec<u8>, eyre::Error> {
+    let (name, params) = parse_signature(signature);
+    let function_selector = compute_function_selector(&name, params.clone());
+
+    let args: Vec<&str> = args.split(' ').collect();
+
+    if params.len() != args.len() {
+        return Err(eyre!(
+            "Number of arguments does not match ({} != {})",
+            params.len(),
+            args.len()
+        ));
+    }
+
+    let mut calldata: Vec<u8> = vec![];
+    let mut dynamic_calldata: Vec<u8> = vec![];
+    if !only_args {
+        calldata.extend(function_selector.as_bytes().to_vec());
+    };
+    for (param, arg) in params.iter().zip(args.clone()) {
+        if param.as_str().ends_with("[]") {
+            let offset: &mut [u8] = &mut [0u8; 32];
+            (U256::from(args.len())
+                .checked_mul(U256::from(32))
+                .expect("Calldata too long")
+                .checked_add(U256::from(dynamic_calldata.len()))
+                .expect("Calldata too long"))
+            .to_big_endian(offset);
+            calldata.extend(offset.to_vec());
+            dynamic_calldata.extend(parse_vec_arg(param, arg));
+        } else {
+            calldata.extend(parse_arg(param, arg));
+        }
+    }
+
+    Ok([calldata, dynamic_calldata].concat())
+}
+
 impl Command {
     pub async fn run(self) -> eyre::Result<()> {
         match self {
@@ -128,45 +187,8 @@ impl Command {
                 args,
                 only_args,
             } => {
-                let (name, params) = parse_signature(&signature);
-                let function_selector = compute_function_selector(&name, params.clone());
-
-                let args: Vec<&str> = args.split(' ').collect();
-
-                if params.len() != args.len() {
-                    println!(
-                        "Number of arguments does not match ({} != {})",
-                        params.len(),
-                        args.len()
-                    );
-                    return Ok(());
-                }
-
-                let mut calldata: Vec<u8> = vec![];
-                let mut dynamic_calldata: Vec<u8> = vec![];
-                if !only_args {
-                    calldata.extend(function_selector.as_bytes().to_vec());
-                };
-                for (param, arg) in params.iter().zip(args.clone()) {
-                    if param.as_str().ends_with("[]") {
-                        let offset: &mut [u8] = &mut [0u8; 32];
-                        (U256::from(args.len())
-                            .checked_mul(U256::from(32))
-                            .expect("Calldata too long")
-                            .checked_add(U256::from(dynamic_calldata.len()))
-                            .expect("Calldata too long"))
-                        .to_big_endian(offset);
-                        calldata.extend(offset.to_vec());
-                        dynamic_calldata.extend(parse_vec_arg(param, arg));
-                    } else {
-                        calldata.extend(parse_arg(param, arg));
-                    }
-                }
-                println!(
-                    "0x{}{}",
-                    hex::encode(calldata),
-                    hex::encode(dynamic_calldata)
-                );
+                let calldata = encode_calldata(&signature, &args, only_args)?;
+                println!("0x{}", hex::encode(calldata));
             }
         };
         Ok(())

cmd/ethereum_rust_l2/src/commands/wallet.rs

@@ -1,10 +1,20 @@
-use crate::config::EthereumRustL2Config;
+use crate::{commands::utils::encode_calldata, config::EthereumRustL2Config};
 use bytes::Bytes;
 use clap::Subcommand;
-use ethereum_rust_core::types::{EIP1559Transaction, TxKind};
-use ethereum_rust_l2::utils::eth_client::{eth_sender::Overrides, EthClient};
+use ethereum_rust_core::types::{
+    EIP1559Transaction, PrivilegedL2Transaction, PrivilegedTxType, Transaction, TxKind,
+};
+use ethereum_rust_l2::utils::{
+    eth_client::{eth_sender::Overrides, EthClient},
+    merkle_tree::merkle_proof,
+};
 use ethereum_types::{Address, H256, U256};
+use eyre::OptionExt;
 use hex::FromHexError;
+use itertools::Itertools;
+
+const CLAIM_WITHDRAWAL_SIGNATURE: &str =
+    "claimWithdrawal(bytes32,uint256,uint256,uint256,bytes32[])";
 
 #[derive(Subcommand)]
 pub(crate) enum Command {
@@ -36,10 +46,7 @@ pub(crate) enum Command {
         explorer_url: bool,
     },
     #[clap(about = "Finalize a pending withdrawal.")]
-    FinalizeWithdraw {
-        #[clap(long = "hash")]
-        l2_withdrawal_tx_hash: H256,
-    },
+    ClaimWithdraw { l2_withdrawal_tx_hash: H256 },
     #[clap(about = "Transfer funds to another wallet.")]
     Transfer {
         // TODO: Parse ether instead.
@@ -63,6 +70,10 @@ pub(crate) enum Command {
         // TODO: Parse ether instead.
         #[clap(long = "amount", value_parser = U256::from_dec_str)]
         amount: U256,
+        #[clap(long = "to")]
+        to: Option<Address>,
+        #[clap(long = "nonce")]
+        nonce: Option<u64>,
         #[clap(
             long = "token",
             help = "Specify the token address, the base token is used as default."
@@ -71,6 +82,11 @@ pub(crate) enum Command {
         #[clap(long, short = 'e', required = false)]
         explorer_url: bool,
     },
+    #[clap(about = "Get the withdrawal merkle proof of a transaction.")]
+    WithdrawalProof {
+        #[clap(long = "hash")]
+        tx_hash: H256,
+    },
     #[clap(about = "Get the wallet address.")]
     Address,
     #[clap(about = "Get the wallet private key.")]
@@ -171,6 +187,50 @@ fn decode_hex(s: &str) -> Result<Bytes, FromHexError> {
     }
 }
 
+async fn get_withdraw_merkle_proof(
+    client: &EthClient,
+    tx_hash: H256,
+) -> Result<(u64, Vec<H256>), eyre::Error> {
+    let tx_receipt = client
+        .get_transaction_receipt(tx_hash)
+        .await?
+        .ok_or_eyre("Transaction receipt not found")?;
+
+    let transactions = client
+        .get_block_by_hash(tx_receipt.block_info.block_hash)
+        .await?
+        .transactions;
+
+    let (index, tx_withdrawal_hash) = transactions
+        .iter()
+        .filter(|tx| match tx {
+            Transaction::PrivilegedL2Transaction(tx) => tx.tx_type == PrivilegedTxType::Withdrawal,
+            _ => false,
+        })
+        .find_position(|tx| tx.compute_hash() == tx_hash)
+        .map(|(i, tx)| match tx {
+            Transaction::PrivilegedL2Transaction(tx) => {
+                (i as u64, tx.get_withdrawal_hash().unwrap())
+            }
+            _ => unreachable!(),
+        })
+        .ok_or_eyre("Transaction is not a Withdrawal")?;
+
+    let path = merkle_proof(
+        transactions
+            .iter()
+            .filter_map(|tx| match tx {
+                Transaction::PrivilegedL2Transaction(tx) => tx.get_withdrawal_hash(),
+                _ => None,
+            })
+            .collect(),
+        tx_withdrawal_hash,
+    )
+    .ok_or_eyre("Transaction's WithdrawalData is not in block's WithdrawalDataMerkleRoot")?;
+
+    Ok((index, path))
+}
+
 impl Command {
     pub async fn run(self, cfg: EthereumRustL2Config) -> eyre::Result<()> {
         let eth_client = EthClient::new(&cfg.network.l1_rpc_url);
@@ -223,10 +283,52 @@ impl Command {
                 })
                 .await?;
             }
-            Command::FinalizeWithdraw {
-                l2_withdrawal_tx_hash: _,
+            Command::ClaimWithdraw {
+                l2_withdrawal_tx_hash,
             } => {
-                todo!()
+                let (withdrawal_l2_block_number, claimed_amount) = match rollup_client
+                    .get_transaction_by_hash(l2_withdrawal_tx_hash)
+                    .await?
+                {
+                    Some(l2_withdrawal_tx) => {
+                        (l2_withdrawal_tx.block_number, l2_withdrawal_tx.value)
+                    }
+                    None => {
+                        println!("Withdrawal transaction not found in L2");
+                        return Ok(());
+                    }
+                };
+
+                let (index, proof) =
+                    get_withdraw_merkle_proof(&rollup_client, l2_withdrawal_tx_hash).await?;
+
+                let claim_withdrawal_data = encode_calldata(
+                    CLAIM_WITHDRAWAL_SIGNATURE,
+                    &format!(
+                        "{l2_withdrawal_tx_hash:#x} {claimed_amount} {withdrawal_l2_block_number} {index} {}",
+                        proof.iter().map(hex::encode).join(",")
+                    ),
+                    false
+                )?;
+                println!(
+                    "ClaimWithdrawalData: {}",
+                    hex::encode(claim_withdrawal_data.clone())
+                );
+
+                let tx_hash = eth_client
+                    .send(
+                        claim_withdrawal_data.into(),
+                        from,
+                        TxKind::Call(cfg.contracts.common_bridge),
+                        cfg.wallet.private_key,
+                        Overrides {
+                            chain_id: Some(cfg.network.l1_chain_id),
+                            ..Default::default()
+                        },
+                    )
+                    .await?;
+
+                println!("Withdrawal claim sent: {tx_hash:#x}");
             }
             Command::Transfer {
                 amount,
@@ -270,11 +372,32 @@ impl Command {
                 );
             }
             Command::Withdraw {
-                amount: _,
+                amount,
+                to,
+                nonce,
                 token_address: _,
                 explorer_url: _,
             } => {
-                todo!()
+                let withdraw_transaction = PrivilegedL2Transaction {
+                    to: TxKind::Call(to.unwrap_or(cfg.wallet.address)),
+                    value: amount,
+                    chain_id: cfg.network.l2_chain_id,
+                    nonce: nonce.unwrap_or(rollup_client.get_nonce(from).await?),
+                    max_fee_per_gas: 800000000,
+                    tx_type: PrivilegedTxType::Withdrawal,
+                    gas_limit: 21000 * 2,
+                    ..Default::default()
+                };
+
+                let tx_hash = rollup_client
+                    .send_privileged_l2_transaction(withdraw_transaction, cfg.wallet.private_key)
+                    .await?;
+
+                println!("Withdrawal sent: {tx_hash:#x}");
+            }
+            Command::WithdrawalProof { tx_hash } => {
+                let (_index, path) = get_withdraw_merkle_proof(&rollup_client, tx_hash).await?;
+                println!("{path:?}");
             }
             Command::Address => {
                 todo!()

crates/common/types/receipt.rs

@@ -70,6 +70,7 @@ impl RLPDecode for Receipt {
                 0x1 => (TxType::EIP2930, &rlp[1..]),
                 0x2 => (TxType::EIP1559, &rlp[1..]),
                 0x3 => (TxType::EIP4844, &rlp[1..]),
+                0x7e => (TxType::Privileged, &rlp[1..]),
                 ty => {
                     return Err(RLPDecodeError::Custom(format!(
                         "Invalid transaction type: {ty}"