feat(l2): allow paying fees with custom token (#5024)

**Motivation**

This pull request introduces support for a new transaction type,
`CustomFeeTransaction`, we want to be able to pay fees with an ERC20
token instead of ETH.

**Description**

* Added `FeeTokenTransaction` as a new variant to the `Transaction`
enum, and updated the `TxType` enum and its associated methods to
recognize the new type.
* Modified `l2_hook` to deduct and refund fees according to the ERC20
tokens desired as the user
* Added new flag for deployer `initial_fee_token` that will register one
address in advance.

**How to test**

You can see the `test_fee_token` in `tests.rs` to see how to build a tx.
Some useful commands may be:

Register a new fee token:
```bash
rex send <BRIDGE_L1> "registerNewFeeToken(address)" <FEE_TOKEN> --rpc-url http://localhost:8545 --private-key 0x941e103320615d394a55708be13e45994c7d93b932b064dbcb2b511fe3254e2e
```

Check if fee token is allowed
```bash
rex call 0x000000000000000000000000000000000000fffc "isFeeToken(address)" <FEE_TOKEN> --rpc-url http://localhost:1729
```

---------

Co-authored-by: Avila Gastón <[email protected]>
Co-authored-by: Manuel Iñaki Bilbao <[email protected]>
Co-authored-by: Copilot <[email protected]>
Co-authored-by: Ivan Litteri <[email protected]>

Author: 5 people

Cargo.lock

@@ -125,6 +125,10 @@ pub fn download_script() {
             &Path::new("../../crates/l2/contracts/src/l2/L2Upgradeable.sol"),
             "UpgradeableSystemContract",
         ),
+        (
+            &Path::new("../../crates/l2/contracts/src/l2/FeeTokenRegistry.sol"),
+            "FeeTokenRegistry",
+        ),
     ];
     for (path, name) in l2_contracts {
         compile_contract_to_bytecode(
@@ -273,7 +277,8 @@ fn decode_to_bytecode(input_file_path: &Path, output_file_path: &Path) {
 
 use ethrex_l2_sdk::{
     COMMON_BRIDGE_L2_ADDRESS, CREATE2DEPLOYER_ADDRESS, DETERMINISTIC_DEPLOYMENT_PROXY_ADDRESS,
-    L2_TO_L1_MESSENGER_ADDRESS, SAFE_SINGLETON_FACTORY_ADDRESS, address_to_word, get_erc1967_slot,
+    FEE_TOKEN_REGISTRY_ADDRESS, L2_TO_L1_MESSENGER_ADDRESS, SAFE_SINGLETON_FACTORY_ADDRESS,
+    address_to_word, get_erc1967_slot,
 };
 
 #[allow(clippy::enum_variant_names)]
@@ -330,6 +335,12 @@ fn l2_to_l1_messenger_runtime(out_dir: &Path) -> Vec<u8> {
     fs::read(path).expect("Failed to read bytecode file")
 }
 
+/// Bytecode of the FeeTokenRegistry contract.
+fn fee_token_registry_runtime(out_dir: &Path) -> Vec<u8> {
+    let path = out_dir.join("contracts/solc_out/FeeTokenRegistry.bytecode");
+    fs::read(path).expect("Failed to read bytecode file")
+}
+
 /// Bytecode of the Create2Deployer contract.
 fn create2deployer_runtime(out_dir: &Path) -> Vec<u8> {
     let path = out_dir.join("contracts/solc_out/Create2Deployer.bytecode");
@@ -433,7 +444,14 @@ pub fn update_genesis_file(
         out_dir,
     )?;
 
-    for address in 0xff00..0xfffd {
+    add_with_proxy(
+        &mut genesis,
+        FEE_TOKEN_REGISTRY_ADDRESS,
+        fee_token_registry_runtime(out_dir),
+        out_dir,
+    )?;
+
+    for address in 0xff00..0xfffc {
         add_placeholder_proxy(&mut genesis, Address::from_low_u64_be(address), out_dir)?;
     }
 

cmd/ethrex/build_l2.rs

@@ -16,6 +16,7 @@ use ethrex_common::{
 use ethrex_l2::utils::test_data_io::read_genesis_file;
 use ethrex_l2_common::{calldata::Value, prover::ProverType, utils::get_address_from_secret_key};
 use ethrex_l2_rpc::signer::{LocalSigner, Signer};
+use ethrex_l2_sdk::register_fee_token;
 use ethrex_l2_sdk::{
     build_generic_tx, calldata::encode_calldata, create2_deploy_from_bytecode,
     deploy_with_proxy_from_bytecode, initialize_contract, send_generic_transaction,
@@ -275,6 +276,16 @@ pub struct DeployerOptions {
         help = "Address of the owner of the CommonBridge contract, who can upgrade the contract."
     )]
     pub bridge_owner: Address,
+    #[arg(
+        long,
+        value_name = "PRIVATE_KEY",
+        value_parser = parse_private_key,
+        env = "ETHREX_BRIDGE_OWNER_PK",
+        help_heading = "Deployer options",
+        help = "Private key of the owner of the CommonBridge contract. If set, the deployer will send a transaction to accept the ownership.",
+        requires = "bridge_owner"
+    )]
+    pub bridge_owner_pk: Option<SecretKey>,
     #[arg(
         long,
         value_name = "PRIVATE_KEY",
@@ -336,6 +347,14 @@ pub struct DeployerOptions {
         help = "Genesis data is extracted at compile time, used for development"
     )]
     pub use_compiled_genesis: bool,
+    #[arg(
+        long,
+        value_name = "ADDRESS",
+        env = "ETHREX_DEPLOYER_INITIAL_FEE_TOKEN",
+        help_heading = "Deployer options",
+        help = "This address will be registered as an initial fee token"
+    )]
+    pub initial_fee_token: Option<Address>,
 }
 
 impl Default for DeployerOptions {
@@ -396,13 +415,25 @@ impl Default for DeployerOptions {
                 0x44, 0x17, 0x09, 0x2b, 0x70, 0xa3, 0xe5, 0xf1, 0x0d, 0xc5, 0x04, 0xd0, 0x94, 0x7d,
                 0xd2, 0x56, 0xb9, 0x65, 0xfc, 0x62,
             ]),
+            // Private Key: 0x941e103320615d394a55708be13e45994c7d93b932b064dbcb2b511fe3254e2e
+            bridge_owner_pk: Some(
+                SecretKey::from_slice(
+                    H256::from_str(
+                        "941e103320615d394a55708be13e45994c7d93b932b064dbcb2b511fe3254e2e",
+                    )
+                    .expect("Bridge owner private key is a valid hex string")
+                    .as_bytes(),
+                )
+                .expect("Bridge owner private key is valid"),
+            ),
             on_chain_proposer_owner_pk: None,
             sp1_vk_path: None,
             risc0_vk_path: None,
             deploy_based_contracts: false,
             sequencer_registry_owner: None,
             inclusion_max_wait: 3000,
             use_compiled_genesis: true,
+            initial_fee_token: None,
         }
     }
 }
@@ -977,7 +1008,7 @@ async fn initialize_contracts(
     info!("Initializing CommonBridge");
     let initialize_tx_hash = {
         let calldata_values = vec![
-            Value::Address(opts.bridge_owner),
+            Value::Address(initializer.address()),
             Value::Address(contract_addresses.on_chain_proposer_address),
             Value::Uint(opts.inclusion_max_wait.into()),
         ];
@@ -994,6 +1025,56 @@ async fn initialize_contracts(
     };
     info!(tx_hash = %format!("{initialize_tx_hash:#x}"), "CommonBridge initialized");
 
+    if let Some(fee_token) = opts.initial_fee_token {
+        register_fee_token(
+            eth_client,
+            contract_addresses.bridge_address,
+            fee_token,
+            initializer,
+        )
+        .await?;
+        info!(?fee_token, "CommonBridge initial fee token registered");
+    }
+
+    if opts.bridge_owner != initializer.address() {
+        let transfer_calldata = encode_calldata(
+            TRANSFER_OWNERSHIP_SIGNATURE,
+            &[Value::Address(opts.bridge_owner)],
+        )?;
+        let transfer_tx_hash = initialize_contract(
+            contract_addresses.bridge_address,
+            transfer_calldata,
+            initializer,
+            eth_client,
+        )
+        .await?;
+        if let Some(owner_pk) = opts.bridge_owner_pk {
+            let signer = Signer::Local(LocalSigner::new(owner_pk));
+            let accept_calldata = encode_calldata(ACCEPT_OWNERSHIP_SIGNATURE, &[])?;
+            let accept_tx = build_generic_tx(
+                eth_client,
+                TxType::EIP1559,
+                contract_addresses.bridge_address,
+                opts.bridge_owner,
+                accept_calldata.into(),
+                Overrides::default(),
+            )
+            .await?;
+            let accept_tx_hash = send_generic_transaction(eth_client, accept_tx, &signer).await?;
+            wait_for_transaction_receipt(accept_tx_hash, eth_client, 100).await?;
+            info!(
+                transfer_tx_hash = %format!("{transfer_tx_hash:#x}"),
+                accept_tx_hash = %format!("{accept_tx_hash:#x}"),
+                "CommonBridge ownership transferred and accepted"
+            );
+        } else {
+            info!(
+                transfer_tx_hash = %format!("{transfer_tx_hash:#x}"),
+                "CommonBridge ownership transfer pending acceptance"
+            );
+        }
+    }
+
     trace!("Contracts initialized");
     Ok(())
 }
@@ -1031,6 +1112,8 @@ async fn make_deposits(
         .map(|line| line.trim().to_string())
         .collect();
 
+    let mut last_hash = None;
+
     for pk in private_keys.iter() {
         let secret_key = parse_private_key(pk).map_err(|_| {
             DeployerError::DecodingError("Error while parsing private key".to_string())
@@ -1070,6 +1153,7 @@ async fn make_deposits(
 
         match send_generic_transaction(eth_client, build, &signer).await {
             Ok(hash) => {
+                last_hash = Some(hash);
                 info!(
                     address =? signer.address(),
                     ?value_to_deposit,
@@ -1084,6 +1168,9 @@ async fn make_deposits(
         }
     }
     trace!("Deposits finished");
+    if let Some(hash) = last_hash {
+        wait_for_transaction_receipt(hash, eth_client, 100).await?;
+    }
     Ok(())
 }
 

cmd/ethrex/l2/deployer.rs

@@ -1382,6 +1382,7 @@ impl Blockchain {
                     "Privileged Transactions are not supported in P2P".to_string(),
                 ));
             }
+            Transaction::FeeTokenTransaction(itx) => P2PTransaction::FeeTokenTransaction(itx),
         };
 
         Ok(result)

crates/blockchain/blockchain.rs

@@ -162,6 +162,7 @@ impl MetricsTxType {
             ethrex_common::types::TxType::EIP4844 => "EIP4844",
             ethrex_common::types::TxType::EIP7702 => "EIP7702",
             ethrex_common::types::TxType::Privileged => "Privileged",
+            ethrex_common::types::TxType::FeeToken => "FeeTokenTransaction",
         }
     }
     pub fn all() -> Vec<String> {
@@ -172,6 +173,7 @@ impl MetricsTxType {
             "EIP4844".to_string(),
             "EIP7702".to_string(),
             "Privileged".to_string(),
+            "FeeToken".to_string(),
         ]
     }
 }

crates/blockchain/metrics/metrics_transactions.rs

@@ -175,6 +175,7 @@ impl ReceiptWithBloom {
                     0x2 => TxType::EIP1559,
                     0x3 => TxType::EIP4844,
                     0x4 => TxType::EIP7702,
+                    0x7d => TxType::FeeToken,
                     0x7e => TxType::Privileged,
                     ty => {
                         return Err(RLPDecodeError::Custom(format!(
@@ -237,6 +238,7 @@ impl RLPDecode for ReceiptWithBloom {
                 0x2 => TxType::EIP1559,
                 0x3 => TxType::EIP4844,
                 0x4 => TxType::EIP7702,
+                0x7d => TxType::FeeToken,
                 0x7e => TxType::Privileged,
                 ty => {
                     return Err(RLPDecodeError::Custom(format!(