fix(coprocessor): support multichain

Author: rudy-6-4

coprocessor/fhevm-engine/.sqlx/query-51b0ba894dbdd2b26c9ad13e1a5b3d4657af9aa912bbe652eabeae2959588589.json

@@ -0,0 +1,5 @@
+ALTER TABLE IF EXISTS host_chain_blocks_valid
+ADD COLUMN IF NOT EXISTS block_status TEXT NOT NULL DEFAULT 'unknown' CHECK (block_status IN ('pending', 'unknown', 'finalized', 'orphaned'));
+
+ALTER TABLE IF EXISTS host_chain_blocks_valid
+ALTER COLUMN block_status DROP DEFAULT;

coprocessor/fhevm-engine/.sqlx/query-641036eba016313ea7cf191d71f2b69c1def70ea46139dd02fb510581b6322c2.json

@@ -40,6 +40,7 @@ pub const DEFAULT_DEPENDENCE_BY_CONNEXITY: bool = false;
 pub const DEFAULT_DEPENDENCE_CROSS_BLOCK: bool = true;
 
 const TIMEOUT_REQUEST_ON_WEBSOCKET: u64 = 15;
+pub const MINIMUM_DELAY_FOR_FINALIZATION_IN_BLOCKS: u64 = 5;
 
 #[derive(Parser, Debug, Clone)]
 #[command(version, about, long_about = None)]
@@ -459,6 +460,7 @@ impl InfiniteLogIter {
                 logs: std::mem::take(&mut current_logs),
                 summary,
                 catchup: true,
+                finalized: self.catchup_finalization_in_blocks > MINIMUM_DELAY_FOR_FINALIZATION_IN_BLOCKS,
             };
             blocks_logs.push(block_logs);
         }
@@ -731,6 +733,7 @@ impl InfiniteLogIter {
                 logs,
                 summary: missing_block,
                 catchup: true,
+                finalized: false, // let catchups with finality conditions do the finalize later
             });
             self.block_history.add_block(missing_block);
         }
@@ -825,6 +828,7 @@ impl InfiniteLogIter {
             logs: self.get_logs_at_hash(block_header.hash).await?,
             summary: block_header.into(),
             catchup: false,
+            finalized: false,
         })
     }
 

coprocessor/fhevm-engine/.sqlx/query-740ca88502667c575985e65d9a600221db69925024f9822e80ba9dd0677044fc.json

@@ -19,6 +19,7 @@ pub struct BlockLogs<T> {
     pub logs: Vec<T>,
     pub summary: BlockSummary,
     pub catchup: bool,
+    pub finalized: bool,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -309,8 +310,7 @@ pub async fn ingest_block_logs(
             info!(block_number, catchup_insertion, "Catchup inserted events");
         }
     }
-
-    db.mark_block_as_valid(&mut tx, &block_logs.summary).await?;
+    db.mark_block_as_valid(&mut tx, &block_logs.summary, block_logs.finalized).await?;
     if at_least_one_insertion {
         db.update_dependence_chain(
             &mut tx,

coprocessor/fhevm-engine/.sqlx/query-e007c4af2864544c0eaa5d27f456f611b3d9f9909a845f78f85cdd69787c7106.json

@@ -495,19 +495,44 @@ impl Database {
         &self,
         tx: &mut Transaction<'_>,
         block_summary: &BlockSummary,
+        finalized: bool,
     ) -> Result<(), SqlxError> {
+        let status = if finalized { "finalized" } else { "pending" };
+        // 1. Insert if not exists (never overwrites existing row)
         sqlx::query!(
             r#"
-            INSERT INTO host_chain_blocks_valid (chain_id, block_hash, block_number)
-            VALUES ($1, $2, $3)
-            ON CONFLICT (chain_id, block_hash) DO NOTHING;
+            INSERT INTO host_chain_blocks_valid (chain_id, block_hash, block_number, block_status)
+            VALUES ($1, $2, $3, $4)
+            ON CONFLICT (chain_id, block_hash) DO NOTHING
+            ;
             "#,
             self.chain_id.as_i64(),
             block_summary.hash.to_vec(),
             block_summary.number as i64,
+            status,
         )
         .execute(tx.deref_mut())
         .await?;
+
+        // 2. Update to finalized or orphan if needed
+        if finalized {
+            sqlx::query!(
+                r#"
+                UPDATE host_chain_blocks_valid
+                SET block_status = CASE
+                    WHEN block_hash = $2
+                        THEN 'finalized'
+                        ELSE 'orphaned'
+                    END
+                WHERE block_status = 'pending' AND block_number = $3 AND chain_id = $1
+                "#,
+                self.chain_id.as_i64(),
+                block_summary.hash.to_vec(),
+                block_summary.number as i64,
+            )
+            .execute(tx.deref_mut())
+            .await?;
+        }
         Ok(())
     }