fix(sequencer): Send layer-2 transaction

Author: RomanHodulak

metabased-sequencer/interceptor/Cargo.toml

@@ -35,3 +35,4 @@ hyper-util = "0.1.8"
 alloy-primitives = "0.8.7"
 url = { version = "2", features = ["serde"] }
 prometheus-client = "0.22"
+    

metabased-sequencer/interceptor/src/application/send_raw_transaction.rs

@@ -46,7 +46,5 @@ where
         )?;
     }
 
-    chain.process_transaction(encoded).await?;
-
-    Ok(tx.tx_hash().to_owned())
+    Ok(chain.process_transaction(encoded).await?)
 }

metabased-sequencer/interceptor/src/domain/chain.rs

@@ -1,14 +1,14 @@
-use super::primitives::Bytes;
+use super::primitives::{Bytes, TxHash};
 use jsonrpsee::core::async_trait;
 use std::error::Error;
 
 #[async_trait]
 pub trait MetabasedSequencerChainService {
     type Error: Error;
 
-    async fn process_transaction(&self, tx: Bytes) -> Result<(), Self::Error>;
+    async fn process_transaction(&self, tx: Bytes) -> Result<TxHash, Self::Error>;
 
-    async fn process_bulk_transactions(&self, tx: Vec<Bytes>) -> Result<(), Self::Error>;
+    async fn process_bulk_transactions(&self, tx: Vec<Bytes>) -> Result<TxHash, Self::Error>;
 }
 
 #[cfg(test)]
@@ -36,16 +36,16 @@ mod tests {
     impl MetabasedSequencerChainService for InMemoryMetabasedSequencerChain {
         type Error = Infallible;
 
-        async fn process_transaction(&self, tx: Bytes) -> Result<(), Infallible> {
+        async fn process_transaction(&self, tx: Bytes) -> Result<TxHash, Infallible> {
             self.transactions.write().await.push(tx);
 
-            Ok(())
+            Ok(TxHash::ZERO)
         }
 
-        async fn process_bulk_transactions(&self, tx: Vec<Bytes>) -> Result<(), Infallible> {
+        async fn process_bulk_transactions(&self, tx: Vec<Bytes>) -> Result<TxHash, Infallible> {
             self.transactions.write().await.extend(tx);
 
-            Ok(())
+            Ok(TxHash::ZERO)
         }
     }
 }

metabased-sequencer/interceptor/src/domain/primitives.rs

@@ -1 +1 @@
-pub use alloy::primitives::{Address, Bytes};
+pub use alloy::primitives::{Address, Bytes, TxHash, B256};

metabased-sequencer/interceptor/src/infrastructure/sol.rs

@@ -1,12 +1,13 @@
-use crate::domain::primitives::{Address, Bytes};
+use crate::domain::primitives::{Address, Bytes, TxHash};
 use crate::domain::MetabasedSequencerChainService;
 use crate::infrastructure::sol::MetabasedSequencerChain::MetabasedSequencerChainInstance;
 use alloy::network::Network;
 use alloy::providers::Provider;
-use alloy::sol;
 use alloy::transports::Transport;
+use alloy::sol;
 use async_trait::async_trait;
 use std::marker::PhantomData;
+use std::time::Duration;
 
 sol! {
     #[derive(Debug, PartialEq, Eq)]
@@ -51,15 +52,27 @@ impl<P: Provider<T, N>, T: Transport + Clone, N: Network> MetabasedSequencerChai
 {
     type Error = alloy::contract::Error;
 
-    async fn process_transaction(&self, tx: Bytes) -> Result<(), Self::Error> {
-        self.contract().processTransaction(tx).call().await?;
-
-        Ok(())
+    async fn process_transaction(&self, tx: Bytes) -> Result<TxHash, Self::Error> {
+        Ok(self
+            .contract()
+            .processTransaction(tx)
+            .send()
+            .await?
+            .with_required_confirmations(2)
+            .with_timeout(Some(Duration::from_secs(60)))
+            .watch()
+            .await?)
     }
 
-    async fn process_bulk_transactions(&self, tx: Vec<Bytes>) -> Result<(), Self::Error> {
-        self.contract().processBulkTransactions(tx).call().await?;
-
-        Ok(())
+    async fn process_bulk_transactions(&self, tx: Vec<Bytes>) -> Result<TxHash, Self::Error> {
+        Ok(self
+            .contract()
+            .processBulkTransactions(tx)
+            .send()
+            .await?
+            .with_required_confirmations(2)
+            .with_timeout(Some(Duration::from_secs(60)))
+            .watch()
+            .await?)
     }
 }

metabased-sequencer/interceptor/src/presentation/cli.rs

@@ -1,5 +1,6 @@
 use crate::domain::primitives::Address;
 use crate::presentation::server;
+use alloy_primitives::B256;
 use clap::{Parser, ValueEnum};
 use figment::providers::{Env, Serialized};
 use figment::Figment;
@@ -23,6 +24,7 @@ pub async fn run() -> anyhow::Result<()> {
         args.port,
         args.chain_contract_address,
         args.chain_rpc_address,
+        args.private_key,
     )
     .await?;
 
@@ -96,6 +98,10 @@ struct CliArgs {
     #[arg(short = 'p', long)]
     port: Option<u16>,
 
+    /// Private key to sign layer-2 transactions with.
+    #[arg(short = 'k', long)]
+    private_key: B256,
+
     /// Profile that chooses which .env file to load
     #[arg(short = 'o', long)]
     profile: Option<Profile>,
@@ -104,6 +110,7 @@ struct CliArgs {
 struct Args {
     chain_contract_address: Address,
     chain_rpc_address: Url,
+    private_key: B256,
     port: u16,
 }
 
@@ -112,6 +119,7 @@ impl From<CliArgs> for Args {
         Self {
             chain_contract_address: value.chain_contract_address,
             chain_rpc_address: value.chain_rpc_address,
+            private_key: value.private_key,
             port: value.port.expect("port should be set by a default value"),
         }
     }

metabased-sequencer/interceptor/src/presentation/server.rs

@@ -4,7 +4,13 @@ use crate::domain::MetabasedSequencerChainService;
 use crate::infrastructure::SolMetabasedSequencerChainService;
 use crate::presentation::json_rpc_errors::Error;
 use crate::presentation::jsonrpc;
-use alloy::providers::ProviderBuilder;
+use alloy::network::{Ethereum, EthereumWallet};
+use alloy::primitives::B256;
+use alloy::providers::fillers::{
+    CachedNonceManager, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller, WalletFiller,
+};
+use alloy::providers::{ReqwestProvider, RootProvider};
+use alloy::signers::local::PrivateKeySigner;
 use jsonrpsee::server::{RpcServiceBuilder, Server, ServerHandle};
 use jsonrpsee::RpcModule;
 use std::net::SocketAddr;
@@ -14,30 +20,57 @@ pub async fn run(
     port: u16,
     chain_contract_address: Address,
     chain_rpc_address: Url,
+    private_key: B256,
 ) -> anyhow::Result<(SocketAddr, ServerHandle)> {
+    let chain = create_chain_service(chain_contract_address, chain_rpc_address, private_key)?;
+    let metrics = PrometheusMetrics::new();
+    let services = Services::new(chain, metrics);
+
     let rpc_middleware = RpcServiceBuilder::new();
     let server = Server::builder()
         .set_rpc_middleware(rpc_middleware)
         .build(format!("127.0.0.1:{port}"))
         .await?;
+
     let addr = server.local_addr()?;
-    let rpc = ProviderBuilder::new().on_http(chain_rpc_address);
-    let chain = SolMetabasedSequencerChainService::new(chain_contract_address, rpc);
-    let metrics = PrometheusMetrics::new();
-    let services = Services { chain, metrics };
     let module = create_eth_module(services)?;
     let handle = server.start(module);
 
     Ok((addr, handle))
 }
 
+fn create_chain_service(
+    chain_contract_address: Address,
+    chain_rpc_address: Url,
+    private_key: B256,
+) -> anyhow::Result<
+    impl MetabasedSequencerChainService<Error = alloy::contract::Error> + Send + Sync + 'static,
+> {
+    let signer = PrivateKeySigner::from_bytes(&private_key)?;
+    let wallet = EthereumWallet::from(signer);
+    let filler = JoinFill::new(
+        NonceFiller::new(CachedNonceManager::default()),
+        JoinFill::new(
+            WalletFiller::new(wallet),
+            JoinFill::new(GasFiller, ChainIdFiller::new(None)),
+        ),
+    );
+    let rpc: RootProvider<_, Ethereum> = ReqwestProvider::new_http(chain_rpc_address);
+    let rpc = FillProvider::new(rpc, filler);
+
+    Ok(SolMetabasedSequencerChainService::new(
+        chain_contract_address,
+        rpc,
+    ))
+}
+
 fn create_eth_module<Chain, M>(
     services: Services<Chain, M>,
 ) -> anyhow::Result<RpcModule<Services<Chain, M>>>
 where
     Chain: MetabasedSequencerChainService + Send + Sync + 'static,
-    M: Metrics + Send + Sync + 'static,
     Error: From<<Chain as MetabasedSequencerChainService>::Error>,
+    M: Metrics + Send + Sync + 'static,
 {
     let mut module = RpcModule::new(services);
     module.register_async_method("eth_sendRawTransaction", jsonrpc::send_raw_transaction)?;
@@ -52,6 +85,10 @@ pub struct Services<Chain, M> {
 }
 
 impl<Chain: MetabasedSequencerChainService, M: Metrics> Services<Chain, M> {
+    pub fn new(chain: Chain, metrics: M) -> Self {
+        Self { chain, metrics }
+    }
+
     pub fn chain_service(&self) -> &Chain {
         &self.chain
     }