feat(cli): support erc20 transfers

cli/src/cli.rs

@@ -8,15 +8,15 @@ use crate::{
 };
 use clap::{ArgAction, Parser, Subcommand};
 use ethrex_common::types::{AuthorizationTupleEntry, TxType};
-use ethrex_common::{Address, Bytes, H256, H520};
+use ethrex_common::{Address, Bytes, H256, H520, U256};
 use ethrex_l2_common::calldata::Value;
 use ethrex_l2_common::utils::get_address_from_secret_key;
 use ethrex_l2_rpc::signer::{LocalSigner, Signer};
 use ethrex_rlp::encode::RLPEncode;
 use ethrex_rpc::EthClient;
 use ethrex_rpc::clients::Overrides;
 use ethrex_rpc::types::block_identifier::{BlockIdentifier, BlockTag};
-use ethrex_sdk::calldata::decode_calldata;
+use ethrex_sdk::calldata::{decode_calldata, encode_calldata};
 use ethrex_sdk::{build_generic_tx, create2_deploy_from_bytecode, send_generic_transaction};
 use ethrex_sdk::{compile_contract, git_clone};
 use keccak_hash::keccak;
@@ -450,27 +450,45 @@ impl Command {
                 println!("{signer:x?}");
             }
             Command::Transfer { args, rpc_url } => {
-                if args.token_address.is_some() {
-                    todo!("Handle ERC20 transfers")
-                }
-
                 if args.explorer_url {
                     todo!("Display transaction URL in the explorer")
                 }
 
+                let client = EthClient::new(rpc_url)?;
                 let from = get_address_from_secret_key(&args.private_key.secret_bytes())
                     .map_err(|e| eyre::eyre!(e))?;
-
-                let client = EthClient::new(rpc_url)?;
+                let (to, calldata, overrides) = if let Some(token_address) = args.token_address {
+                    let signature = "transfer(address,uint256)";
+                    let values = vec![Value::Address(args.to), Value::Uint(args.amount)];
+                    let calldata = encode_calldata(signature, &values)?;
+
+                    (
+                        token_address,
+                        Some(calldata.into()),
+                        Overrides {
+                            value: Some(U256::zero()),
+                            ..Default::default()
+                        },
+                    )
+                } else {
+                    (
+                        args.to,
+                        None,
+                        Overrides {
+                            value: Some(args.amount),
+                            ..Default::default()
+                        },
+                    )
+                };
 
                 let tx_hash = transfer(
-                    args.amount,
                     from,
-                    args.to,
+                    to,
                     TxType::EIP1559,
                     &args.private_key,
                     &client,
-                    Overrides::default(),
+                    overrides,
+                    calldata,
                 )
                 .await?;
 

cli/src/commands/l2.rs

@@ -6,11 +6,11 @@ use crate::{
 use clap::Subcommand;
 use ethrex_common::{Address, H256, U256};
 use ethrex_common::{Bytes, types::TxType};
-use ethrex_l2_common::utils::get_address_from_secret_key;
+use ethrex_l2_common::{calldata::Value, utils::get_address_from_secret_key};
 use ethrex_l2_rpc::clients::{get_batch_by_number, get_batch_number};
 use ethrex_rpc::EthClient;
 use ethrex_rpc::clients::Overrides;
-use ethrex_sdk::wait_for_l1_message_proof;
+use ethrex_sdk::{calldata::encode_calldata, wait_for_l1_message_proof};
 use rex_sdk::transfer;
 use rex_sdk::{
     l2::authorize::send_authorized_transaction,
@@ -572,10 +572,6 @@ impl Command {
                 fee_token,
                 rpc_url,
             } => {
-                if args.token_address.is_some() {
-                    todo!("Handle ERC20 transfers")
-                }
-
                 if args.explorer_url {
                     todo!("Display transaction URL in the explorer")
                 }
@@ -590,17 +586,40 @@ impl Command {
                     TxType::EIP1559
                 };
 
+                let (to, calldata, overrides) = if let Some(token_address) = args.token_address {
+                    let signature = "transfer(address,uint256)";
+                    let values = vec![Value::Address(args.to), Value::Uint(args.amount)];
+                    let calldata = encode_calldata(signature, &values)?;
+
+                    (
+                        token_address,
+                        Some(calldata.into()),
+                        Overrides {
+                            fee_token,
+                            value: Some(U256::zero()),
+                            ..Default::default()
+                        },
+                    )
+                } else {
+                    (
+                        args.to,
+                        None,
+                        Overrides {
+                            fee_token,
+                            value: Some(args.amount),
+                            ..Default::default()
+                        },
+                    )
+                };
+
                 let tx_hash = transfer(
-                    args.amount,
                     from,
-                    args.to,
+                    to,
                     tx_type,
                     &args.private_key,
                     &client,
-                    Overrides {
-                        fee_token,
-                        ..Default::default()
-                    },
+                    overrides,
+                    calldata,
                 )
                 .await?;
 
@@ -638,7 +657,6 @@ impl Command {
                     .l1_fee_vault_address
                     .map(|addr| format!("{addr:#x}"))
                     .unwrap_or_else(String::new);
-
                 println!("L2 fee info for block {}:", fee_info.block_number);
                 println!("  Base fee vault:                     {base_fee_vault_address}");
                 println!("  Operator fee vault:                 {operator_fee_vault_address}");

sdk/examples/keystore/main.rs

@@ -67,13 +67,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let rich_wallet_address = get_address_from_secret_key(&rich_wallet_pk.secret_bytes())?;
     let amount = U256::from_dec_str("1000000000000000000").expect("Failed to parse amount");
     let transfer_tx_hash = transfer(
-        amount,
         rich_wallet_address,
         keystore_address,
         TxType::EIP1559,
         &rich_wallet_pk,
         &eth_client,
-        Overrides::default(),
+        Overrides {
+            value: Some(amount),
+            ..Default::default()
+        },
+        None,
     )
     .await?;
 

sdk/examples/simple_usage.rs

@@ -61,13 +61,16 @@ async fn main() {
     let to = Address::from_str("0x4852f44fd706e34cb906b399b729798665f64a83").unwrap();
 
     let tx_hash = transfer(
-        amount,
         from,
         to,
         TxType::EIP1559,
         &args.private_key,
         &eth_client,
-        Overrides::default(),
+        Overrides {
+            value: Some(amount),
+            ..Default::default()
+        },
+        None,
     )
     .await
     .unwrap();

sdk/src/l2/deposit.rs

@@ -21,13 +21,16 @@ pub async fn deposit_through_transfer(
     eth_client: &EthClient,
 ) -> Result<H256, EthClientError> {
     transfer(
-        amount,
         from,
         bridge_address,
         TxType::EIP1559,
         from_pk,
         eth_client,
-        Overrides::default(),
+        Overrides {
+            value: Some(amount),
+            ..Default::default()
+        },
+        None,
     )
     .await
 }

sdk/src/sdk.rs

@@ -36,16 +36,16 @@ pub enum SdkError {
 }
 
 pub async fn transfer(
-    amount: U256,
     from: Address,
     to: Address,
     tx_type: TxType,
     private_key: &SecretKey,
     client: &EthClient,
-    mut overrides: Overrides,
+    overrides: Overrides,
+    calldata: Option<Bytes>,
 ) -> Result<H256, EthClientError> {
-    overrides.value = Some(amount);
-    let tx = build_generic_tx(client, tx_type, to, from, Bytes::new(), overrides).await?;
+    let calldata = calldata.unwrap_or_default();
+    let tx = build_generic_tx(client, tx_type, to, from, calldata, overrides).await?;
 
     let signer = LocalSigner::new(*private_key).into();
     send_generic_transaction(client, tx, &signer).await

sdk/tests/tests.rs

@@ -721,13 +721,16 @@ async fn perform_transfer(
         .await?;
 
     let transfer_tx = transfer(
-        transfer_value,
         transferer_address,
         transfer_recipient_address,
         TxType::EIP1559,
         transferer_private_key,
         proposer_client,
-        Overrides::default(),
+        Overrides {
+            value: Some(transfer_value),
+            ..Default::default()
+        },
+        None,
     )
     .await?;