feat: add web3 signer support for op-succinct-lite (#514)

* refac: make ProposerSigner util

* feat: add web3 signer support to op-succinct-lite

* chore: clean up + missing changes

* fix + ci + docs + chore

* refac: add Signer::from_env()

* chore: add .

* apply comments

* refac: rename send_transaction_request_inner

Author: fakedev9999

.github/workflows/pr.yaml

@@ -35,7 +35,7 @@ jobs:
         with:
           profile: minimal
           toolchain: nightly
-          components: rustfmt
+          components: rustfmt, clippy
 
       - name: Run cargo check
         uses: actions-rs/cargo@v1

Cargo.lock

@@ -6,6 +6,7 @@ members = [
     "utils/celestia/client",
     "utils/celestia/host",
     "utils/proof",
+    "utils/signer",
     "utils/ethereum/client",
     "utils/ethereum/host",
     "programs/range/*",
@@ -97,6 +98,7 @@ op-succinct-ethereum-host-utils = { path = "utils/ethereum/host" }
 op-succinct-celestia-client-utils = { path = "utils/celestia/client" }
 op-succinct-celestia-host-utils = { path = "utils/celestia/host" }
 op-succinct-proof-utils = { path = "utils/proof" }
+op-succinct-signer-utils = { path = "utils/signer" }
 op-succinct-range-utils = { path = "programs/range/utils" }
 
 # Alloy (Network)

Cargo.toml

@@ -35,7 +35,14 @@ The challenger is configured through environment variables. Create a `.env.chall
 | `L2_RPC` | L2 RPC endpoint URL |
 | `FACTORY_ADDRESS` | Address of the DisputeGameFactory contract |
 | `GAME_TYPE` | Type identifier for the dispute game |
-| `PRIVATE_KEY` | Private key for transaction signing |
+
+Either `PRIVATE_KEY` or both `SIGNER_URL` and `SIGNER_ADDRESS` must be set for transaction signing:
+
+| Variable | Description |
+|----------|-------------|
+| `PRIVATE_KEY` | Private key for transaction signing (if using private key signer) |
+| `SIGNER_URL` | URL of the web3 signer service (if using web3 signer) |
+| `SIGNER_ADDRESS` | Address of the account managed by the web3 signer (if using web3 signer) |
 
 ### Optional Environment Variables
 

book/fault_proofs/challenger.md

@@ -35,9 +35,16 @@ The proposer is configured through various environment variables. Create a `.env
 | `L2_RPC` | L2 RPC endpoint URL |
 | `FACTORY_ADDRESS` | Address of the DisputeGameFactory contract |
 | `GAME_TYPE` | Type identifier for the dispute game |
-| `PRIVATE_KEY` | Private key for transaction signing |
 | `NETWORK_PRIVATE_KEY` | Private key for the succinct prover network (Set to `0x0000000000000000000000000000000000000000000000000000000000000001` if not using fast finality mode) |
 
+Either `PRIVATE_KEY` or both `SIGNER_URL` and `SIGNER_ADDRESS` must be set for transaction signing:
+
+| Variable | Description |
+|----------|-------------|
+| `PRIVATE_KEY` | Private key for transaction signing (if using private key signer) |
+| `SIGNER_URL` | URL of the web3 signer service (if using web3 signer) |
+| `SIGNER_ADDRESS` | Address of the account managed by the web3 signer (if using web3 signer) |
+
 To get a whitelisted key on the Succinct Prover Network for OP Succinct, fill out this [form](https://docs.google.com/forms/d/e/1FAIpQLSd2Yil8TrU54cIuohH1WvDvbxTusyqh5rsDmMAtGC85-Arshg/viewform?ref=https://succinctlabs.github.io/op-succinct/). The Succinct team will reach out to you with an RPC endpoint you can use.
 
 ### Optional Environment Variables
@@ -64,7 +71,13 @@ L1_RPC=                  # L1 RPC endpoint URL
 L2_RPC=                  # L2 RPC endpoint URL
 FACTORY_ADDRESS=         # Address of the DisputeGameFactory contract (obtained from deployment)
 GAME_TYPE=               # Type identifier for the dispute game (must match factory configuration)
+
+# Transaction Signing Configuration (Choose one)
+# Option 1: Private Key Signer
 PRIVATE_KEY=             # Private key for transaction signing
+# Option 2: Web3 Signer
+SIGNER_URL=              # URL of the web3 signer service
+SIGNER_ADDRESS=          # Address of the account managed by the web3 signer
 
 # Optional Configuration
 MOCK_MODE=false                          # Whether to use mock mode

book/fault_proofs/proposer.md

@@ -31,9 +31,14 @@ This guide provides the fastest path to try out OP Succinct fault dispute games
     DISPUTE_GAME_FINALITY_DELAY_SECONDS=604800
     MAX_CHALLENGE_DURATION=604800
     MAX_PROVE_DURATION=86400
-    STARTING_ROOT=0xbd4ab027af3c4db0c6b1329dad6d9f8e2505accabec75bfaa2b6b8033c1e60c5...
+    STARTING_ROOT=0xbd4ab027af3c4db0c6b1329dad6d9f8e2505accabec75bfaa2b6b8033c1e60c5
     STARTING_L2_BLOCK_NUMBER=791000
 
+    # Optional
+    # Warning: Setting PERMISSIONLESS_MODE=true allows anyone to propose and challenge games. Ensure this behavior is intended for your deployment.
+    # For a permissioned setup, set this to false and configure PROPOSER_ADDRESSES and CHALLENGER_ADDRESSES.
+    PERMISSIONLESS_MODE=true
+
     # For testing, use mock verifier
     USE_SP1_MOCK_VERIFIER=true
     ```
@@ -54,7 +59,9 @@ Save the output addresses, particularly the `FACTORY_ADDRESS` output as "Factory
     ```env
     # Required Configuration
     L1_RPC=<YOUR_L1_RPC_URL>
+    L1_BEACON_RPC=<L1_BEACON_RPC_URL>
     L2_RPC=<YOUR_L2_RPC_URL>
+    L2_NODE_RPC=<L2_NODE_RPC_URL>
     FACTORY_ADDRESS=<FACTORY_ADDRESS_FROM_DEPLOYMENT>
     GAME_TYPE=42
     PRIVATE_KEY=<YOUR_PRIVATE_KEY>
@@ -72,8 +79,6 @@ Save the output addresses, particularly the `FACTORY_ADDRESS` output as "Factory
     ```env
     FAST_FINALITY_MODE=true
     NETWORK_PRIVATE_KEY=0x...
-    L1_BEACON_RPC=<L1_BEACON_RPC_URL>
-    L2_NODE_RPC=<L2_NODE_RPC_URL>
     ```
 
 To get a whitelisted key on the Succinct Prover Network for OP Succinct, fill out this [form](https://docs.google.com/forms/d/e/1FAIpQLSd-X9uH7G0bvXH_kjptnQtNil8L4dumrVPpFE4t8Ci1XT1GaQ/viewform). The Succinct team will reach out to you with an RPC endpoint you can use.

book/fault_proofs/quick_start.md

@@ -25,18 +25,17 @@ op-succinct-client-utils.workspace = true
 op-succinct-elfs.workspace = true
 op-succinct-host-utils.workspace = true
 op-succinct-proof-utils.workspace = true
+op-succinct-signer-utils.workspace = true
 
 # sp1
 sp1-sdk.workspace = true
 
 # alloy
 alloy-contract.workspace = true
 alloy-eips.workspace = true
-alloy-network.workspace = true
 alloy-primitives.workspace = true
 alloy-provider = { workspace = true, features = ["reqwest"] }
 alloy-rpc-types-eth.workspace = true
-alloy-signer-local.workspace = true
 alloy-sol-macro.workspace = true
 alloy-sol-types.workspace = true
 alloy-transport-http = { workspace = true, features = ["reqwest", "reqwest-native-tls"] }
@@ -59,6 +58,9 @@ hex.workspace = true
 strum = { workspace = true, features = ["derive"] }
 strum_macros.workspace = true
 
+[dev-dependencies]
+alloy-signer-local.workspace = true
+
 [features]
 default = ["ethereum"]
 celestia = ["op-succinct-proof-utils/celestia"]

fault-proof/Cargo.toml

@@ -1,15 +1,10 @@
 use std::{env, time::Duration};
 
-use alloy_network::Ethereum;
 use alloy_primitives::{Address, U256};
-use alloy_provider::{fillers::TxFiller, Provider, ProviderBuilder};
-use alloy_signer_local::PrivateKeySigner;
+use alloy_provider::{Provider, ProviderBuilder};
 use alloy_transport_http::reqwest::Url;
-use anyhow::{Context, Result};
+use anyhow::Result;
 use clap::Parser;
-use op_alloy_network::EthereumWallet;
-use tokio::time;
-
 use fault_proof::{
     config::ChallengerConfig,
     contract::{
@@ -18,70 +13,67 @@ use fault_proof::{
     },
     prometheus::ChallengerGauge,
     utils::setup_logging,
-    Action, FactoryTrait, L1ProviderWithWallet, L2Provider, Mode, NUM_CONFIRMATIONS,
-    TIMEOUT_SECONDS,
+    Action, FactoryTrait, L1Provider, L2Provider, Mode,
 };
 use op_succinct_host_utils::metrics::{init_metrics, MetricsGauge};
+use op_succinct_signer_utils::Signer;
+use tokio::time;
 
 #[derive(Parser)]
 struct Args {
     #[arg(long, default_value = ".env.challenger")]
     env_file: String,
 }
 
-struct OPSuccinctChallenger<F, P>
+struct OPSuccinctChallenger<P>
 where
-    F: TxFiller<Ethereum>,
-    P: Provider<Ethereum> + Clone,
+    P: Provider + Clone,
 {
     config: ChallengerConfig,
     challenger_address: Address,
+    signer: Signer,
+    l1_provider: L1Provider,
     l2_provider: L2Provider,
-    l1_provider_with_wallet: L1ProviderWithWallet<F, P>,
-    factory: DisputeGameFactoryInstance<L1ProviderWithWallet<F, P>>,
+    factory: DisputeGameFactoryInstance<P>,
     challenger_bond: U256,
 }
 
-impl<F, P> OPSuccinctChallenger<F, P>
+impl<P> OPSuccinctChallenger<P>
 where
-    F: TxFiller<Ethereum>,
-    P: Provider<Ethereum> + Clone,
+    P: Provider + Clone,
 {
     /// Creates a new challenger instance with the provided L1 provider with wallet and factory
     /// contract instance.
     pub async fn new(
         challenger_address: Address,
-        l1_provider_with_wallet: L1ProviderWithWallet<F, P>,
-        factory: DisputeGameFactoryInstance<L1ProviderWithWallet<F, P>>,
+        signer: Signer,
+        l1_provider: L1Provider,
+        factory: DisputeGameFactoryInstance<P>,
     ) -> Result<Self> {
         let config = ChallengerConfig::from_env()?;
 
         Ok(Self {
             config: config.clone(),
             challenger_address,
+            signer,
+            l1_provider: l1_provider.clone(),
             l2_provider: ProviderBuilder::default().connect_http(config.l2_rpc.clone()),
-            l1_provider_with_wallet: l1_provider_with_wallet.clone(),
             factory: factory.clone(),
             challenger_bond: factory.fetch_challenger_bond(config.game_type).await?,
         })
     }
 
     /// Challenges a specific game at the given address.
     async fn challenge_game(&self, game_address: Address) -> Result<()> {
-        let game =
-            OPSuccinctFaultDisputeGame::new(game_address, self.l1_provider_with_wallet.clone());
+        let game = OPSuccinctFaultDisputeGame::new(game_address, self.l1_provider.clone());
 
-        let receipt = game
-            .challenge()
-            .value(self.challenger_bond)
-            .send()
-            .await
-            .context("Failed to send challenge transaction")?
-            .with_required_confirmations(NUM_CONFIRMATIONS)
-            .with_timeout(Some(Duration::from_secs(TIMEOUT_SECONDS)))
-            .get_receipt()
-            .await
-            .context("Failed to get transaction receipt for challenge")?;
+        let transaction_request =
+            game.challenge().value(self.challenger_bond).into_transaction_request();
+
+        let receipt = self
+            .signer
+            .send_transaction_request(self.config.l1_rpc.clone(), transaction_request)
+            .await?;
 
         tracing::info!(
             "Successfully challenged game {:?} with tx {:?}",
@@ -120,7 +112,9 @@ where
             .resolve_games(
                 Mode::Challenger,
                 self.config.max_games_to_check_for_resolution,
-                self.l1_provider_with_wallet.clone(),
+                self.signer.clone(),
+                self.config.l1_rpc.clone(),
+                self.l1_provider.clone(),
                 self.l2_provider.clone(),
             )
             .await
@@ -142,21 +136,18 @@ where
             tracing::info!("Attempting to claim bond from game {:?}", game_address);
 
             // Create a contract instance for the game
-            let game =
-                OPSuccinctFaultDisputeGame::new(game_address, self.l1_provider_with_wallet.clone());
+            let game = OPSuccinctFaultDisputeGame::new(game_address, self.l1_provider.clone());
 
             // Create a transaction to claim credit
-            let tx = game.claimCredit(self.challenger_address);
-
-            // Send the transaction
-            match tx.send().await {
-                Ok(pending_tx) => {
-                    let receipt = pending_tx
-                        .with_required_confirmations(NUM_CONFIRMATIONS)
-                        .with_timeout(Some(Duration::from_secs(TIMEOUT_SECONDS)))
-                        .get_receipt()
-                        .await?;
-
+            let transaction_request =
+                game.claimCredit(self.challenger_address).into_transaction_request();
+
+            match self
+                .signer
+                .send_transaction_request(self.config.l1_rpc.clone(), transaction_request)
+                .await
+            {
+                Ok(receipt) => {
                     tracing::info!(
                         "\x1b[1mSuccessfully claimed bond from game {:?} with tx {:?}\x1b[0m",
                         game_address,
@@ -232,28 +223,23 @@ async fn main() -> Result<()> {
     let args = Args::parse();
     dotenv::from_filename(args.env_file).ok();
 
-    let wallet = EthereumWallet::from(
-        env::var("PRIVATE_KEY")
-            .expect("PRIVATE_KEY must be set")
-            .parse::<PrivateKeySigner>()
-            .unwrap(),
-    );
+    let challenger_signer = Signer::from_env()?;
 
-    let l1_provider_with_wallet = ProviderBuilder::new()
-        .wallet(wallet.clone())
+    let l1_provider = ProviderBuilder::default()
         .connect_http(env::var("L1_RPC").unwrap().parse::<Url>().unwrap());
 
     let factory = DisputeGameFactory::new(
         env::var("FACTORY_ADDRESS")
             .expect("FACTORY_ADDRESS must be set")
             .parse::<Address>()
             .unwrap(),
-        l1_provider_with_wallet.clone(),
+        l1_provider.clone(),
     );
 
     let mut challenger = OPSuccinctChallenger::new(
-        wallet.default_signer().address(),
-        l1_provider_with_wallet,
+        challenger_signer.address(),
+        challenger_signer,
+        l1_provider,
         factory,
     )
     .await