feat: add handle_bond_claiming for fp challenger (#453)

Author: fakedev9999

book/fault_proofs/challenger.md

@@ -45,6 +45,7 @@ The challenger is configured through environment variables. Create a `.env.chall
 | `ENABLE_GAME_RESOLUTION` | Whether to enable automatic game resolution | `true` |
 | `MAX_GAMES_TO_CHECK_FOR_CHALLENGE` | Maximum number of games to scan for challenges | `100` |
 | `MAX_GAMES_TO_CHECK_FOR_RESOLUTION` | Maximum number of games to check for resolution | `100` |
+| `MAX_GAMES_TO_CHECK_FOR_BOND_CLAIMING` | Maximum number of games to check for bond claiming | `100` |
 | `CHALLENGER_METRICS_PORT` | The port to expose metrics on. Update prometheus.yml to use this port, if using docker compose. | `9001` |
 
 ```env
@@ -60,6 +61,7 @@ FETCH_INTERVAL=30                     # Polling interval in seconds
 ENABLE_GAME_RESOLUTION=true           # Whether to enable automatic game resolution
 MAX_GAMES_TO_CHECK_FOR_CHALLENGE=100  # Maximum number of games to scan for challenges
 MAX_GAMES_TO_CHECK_FOR_RESOLUTION=100 # Maximum number of games to check for resolution
+MAX_GAMES_TO_CHECK_FOR_BOND_CLAIMING=100 # Maximum number of games to check for bond claiming
 CHALLENGER_METRICS_PORT=9001          # The port to expose metrics on
 ```
 

fault-proof/bin/challenger.rs

@@ -35,6 +35,7 @@ where
     P: Provider<Ethereum> + Clone,
 {
     config: ChallengerConfig,
+    challenger_address: Address,
     l2_provider: L2Provider,
     l1_provider_with_wallet: L1ProviderWithWallet<F, P>,
     factory: DisputeGameFactoryInstance<(), L1ProviderWithWallet<F, P>>,
@@ -48,13 +49,15 @@ where
 {
     /// 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>>,
     ) -> Result<Self> {
         let config = ChallengerConfig::from_env()?;
 
         Ok(Self {
             config: config.clone(),
+            challenger_address,
             l2_provider: ProviderBuilder::default().on_http(config.l2_rpc.clone()),
             l1_provider_with_wallet: l1_provider_with_wallet.clone(),
             factory: factory.clone(),
@@ -122,6 +125,58 @@ where
             .await
     }
 
+    /// Handles claiming bonds from resolved games.
+    pub async fn handle_bond_claiming(&self) -> Result<Action> {
+        let _span = tracing::info_span!("[[Claiming Bonds]]").entered();
+
+        if let Some(game_address) = self
+            .factory
+            .get_oldest_claimable_bond_game_address(
+                self.config.game_type,
+                self.config.max_games_to_check_for_bond_claiming,
+                self.challenger_address,
+            )
+            .await?
+        {
+            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());
+
+            // 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?;
+
+                    tracing::info!(
+                        "\x1b[1mSuccessfully claimed bond from game {:?} with tx {:?}\x1b[0m",
+                        game_address,
+                        receipt.transaction_hash
+                    );
+
+                    Ok(Action::Performed)
+                }
+                Err(e) => Err(anyhow::anyhow!(
+                    "Failed to claim bond from game {:?}: {:?}",
+                    game_address,
+                    e
+                )),
+            }
+        } else {
+            tracing::info!("No new games to claim bonds from");
+
+            Ok(Action::Skipped)
+        }
+    }
+
     /// Runs the challenger in an infinite loop, periodically checking for games to challenge and resolve.
     async fn run(&mut self) -> Result<()> {
         tracing::info!("OP Succinct Challenger running...");
@@ -152,6 +207,17 @@ where
                     ChallengerGauge::Errors.increment(1.0);
                 }
             }
+
+            match self.handle_bond_claiming().await {
+                Ok(Action::Performed) => {
+                    ChallengerGauge::GamesBondsClaimed.increment(1.0);
+                }
+                Ok(Action::Skipped) => {}
+                Err(e) => {
+                    tracing::warn!("Failed to handle bond claiming: {:?}", e);
+                    ChallengerGauge::Errors.increment(1.0);
+                }
+            }
         }
     }
 }
@@ -182,9 +248,13 @@ async fn main() -> Result<()> {
         l1_provider_with_wallet.clone(),
     );
 
-    let mut challenger = OPSuccinctChallenger::new(l1_provider_with_wallet, factory)
-        .await
-        .unwrap();
+    let mut challenger = OPSuccinctChallenger::new(
+        wallet.default_signer().address(),
+        l1_provider_with_wallet,
+        factory,
+    )
+    .await
+    .unwrap();
 
     // Initialize challenger gauges.
     ChallengerGauge::register_all();

fault-proof/src/config.rs

@@ -119,6 +119,9 @@ pub struct ChallengerConfig {
     /// challenged up to `max_games_to_check_for_resolution` games behind the latest game.
     pub max_games_to_check_for_resolution: u64,
 
+    /// The maximum number of games to check for bond claiming.
+    pub max_games_to_check_for_bond_claiming: u64,
+
     /// The metrics port.
     pub metrics_port: u16,
 }
@@ -144,6 +147,9 @@ impl ChallengerConfig {
             max_games_to_check_for_resolution: env::var("MAX_GAMES_TO_CHECK_FOR_RESOLUTION")
                 .unwrap_or("100".to_string())
                 .parse()?,
+            max_games_to_check_for_bond_claiming: env::var("MAX_GAMES_TO_CHECK_FOR_BOND_CLAIMING")
+                .unwrap_or("100".to_string())
+                .parse()?,
             metrics_port: env::var("CHALLENGER_METRICS_PORT")
                 .unwrap_or("9001".to_string())
                 .parse()?,

fault-proof/src/prometheus.rs

@@ -60,6 +60,11 @@ pub enum ChallengerGauge {
         message = "Total number of games resolved by the challenger"
     )]
     GamesResolved,
+    #[strum(
+        serialize = "op_succinct_fp_challenger_games_bonds_claimed",
+        message = "Total number of games that bonds were claimed by the challenger"
+    )]
+    GamesBondsClaimed,
     // Error metrics
     #[strum(
         serialize = "op_succinct_fp_challenger_errors",