Support splitting Linera block into multiple EVM transactions.

examples/bridge-demo/setup.sh

@@ -299,6 +299,7 @@ for attempt in 1 2 3; do
         --json-parameters "$WRAPPED_PARAMS" \
         --json-argument '{"accounts":{}}' 2>&1) && break
     echo "  Attempt $attempt failed, retrying..." >&2
+    echo "$WRAPPED_APP_OUTPUT" >&2
     sleep 2
 done
 [[ -z "$WRAPPED_APP_OUTPUT" ]] && { echo "ERROR: publish-and-create wrapped-fungible failed after retries" >&2; exit 1; }

linera-bridge/src/evm/microchain.rs

@@ -68,16 +68,16 @@ mod tests {
     }
 
     #[test]
-    fn test_microchain_rejects_duplicate_block() {
+    fn test_microchain_accepts_duplicate_block() {
         let mut microchain = TestMicrochain::new();
 
         microchain.add_block(BlockHeight(1));
 
         assert!(
             microchain
                 .try_add_block(microchain.chain_id, BlockHeight(1))
-                .is_err(),
-            "should reject duplicate block"
+                .is_ok(),
+            "Microchain must accept duplicate addBlock calls; subclass owns dedup"
         );
     }
 

linera-bridge/src/monitor/db.rs

@@ -100,7 +100,10 @@ impl BridgeDb {
         sqlx::query(
             "CREATE TABLE IF NOT EXISTS pending_burns (
                 linera_height     INTEGER NOT NULL,
-                event_index        INTEGER NOT NULL,
+                block_hash        TEXT NOT NULL,
+                tx_index          INTEGER NOT NULL,
+                event_pos_in_tx   INTEGER NOT NULL,
+                event_index       INTEGER NOT NULL,
                 evm_recipient     TEXT NOT NULL,
                 amount            TEXT NOT NULL,
                 raw_cert          BLOB,
@@ -114,7 +117,10 @@ impl BridgeDb {
         sqlx::query(
             "CREATE TABLE IF NOT EXISTS finished_burns (
                 linera_height     INTEGER NOT NULL,
-                event_index        INTEGER NOT NULL,
+                block_hash        TEXT NOT NULL,
+                tx_index          INTEGER NOT NULL,
+                event_pos_in_tx   INTEGER NOT NULL,
+                event_index       INTEGER NOT NULL,
                 evm_recipient     TEXT NOT NULL,
                 amount            TEXT NOT NULL,
                 raw_cert          BLOB,
@@ -217,10 +223,14 @@ impl BridgeDb {
     /// Inserts a new pending burn. Ignores duplicates (idempotent).
     pub async fn insert_burn(&self, burn: &PendingBurn) -> Result<()> {
         sqlx::query(
-            "INSERT OR IGNORE INTO pending_burns (linera_height, event_index, evm_recipient, amount)
-             VALUES (?, ?, ?, ?)",
+            "INSERT OR IGNORE INTO pending_burns
+                (linera_height, block_hash, tx_index, event_pos_in_tx, event_index, evm_recipient, amount)
+             VALUES (?, ?, ?, ?, ?, ?, ?)",
         )
         .bind(burn.height.0 as i64)
+        .bind(burn.block_hash.to_string())
+        .bind(burn.tx_index as i64)
+        .bind(burn.event_pos_in_tx as i64)
         .bind(burn.event_index as i64)
         .bind(format!("{:#x}", burn.evm_recipient))
         .bind(burn.amount.to_string())
@@ -244,10 +254,10 @@ impl BridgeDb {
         let mut tx = self.pool.begin().await?;
         let inserted = sqlx::query(
             "INSERT OR IGNORE INTO finished_burns
-                (linera_height, event_index, evm_recipient, amount, raw_cert,
-                 status, created_at)
-             SELECT linera_height, event_index, evm_recipient, amount, raw_cert,
-                    ?, created_at
+                (linera_height, block_hash, tx_index, event_pos_in_tx, event_index,
+                 evm_recipient, amount, raw_cert, status, created_at)
+             SELECT linera_height, block_hash, tx_index, event_pos_in_tx, event_index,
+                    evm_recipient, amount, raw_cert, ?, created_at
              FROM pending_burns
              WHERE linera_height = ? AND event_index = ?",
         )
@@ -321,7 +331,7 @@ impl BridgeDb {
     /// in-memory `MonitorState`.
     pub async fn load_pending_burns(&self) -> Result<Vec<PendingBurn>> {
         let rows = sqlx::query(
-            "SELECT linera_height, event_index, evm_recipient, amount
+            "SELECT linera_height, block_hash, tx_index, event_pos_in_tx, event_index, evm_recipient, amount
              FROM pending_burns",
         )
         .fetch_all(&self.pool)
@@ -330,12 +340,20 @@ impl BridgeDb {
         let mut out = Vec::with_capacity(rows.len());
         for row in rows {
             let height: i64 = row.get(0);
-            let event_index: i64 = row.get(1);
-            let evm_recipient: String = row.get(2);
-            let amount: String = row.get(3);
+            let block_hash: String = row.get(1);
+            let tx_index: i64 = row.get(2);
+            let event_pos_in_tx: i64 = row.get(3);
+            let event_index: i64 = row.get(4);
+            let evm_recipient: String = row.get(5);
+            let amount: String = row.get(6);
 
             out.push(PendingBurn {
                 height: BlockHeight(height as u64),
+                block_hash: block_hash
+                    .parse()
+                    .context("invalid block_hash in burns row")?,
+                tx_index: tx_index as u32,
+                event_pos_in_tx: event_pos_in_tx as u32,
                 event_index: event_index as u32,
                 evm_recipient: evm_recipient
                     .parse()
@@ -382,7 +400,7 @@ mod tests {
     use std::sync::atomic::{AtomicU32, Ordering};
 
     use alloy::primitives::{Address, B256, U256};
-    use linera_base::data_types::Amount;
+    use linera_base::{crypto::CryptoHash, data_types::Amount};
     use test_case::test_case;
 
     use super::*;
@@ -422,6 +440,9 @@ mod tests {
     fn test_burn() -> PendingBurn {
         PendingBurn {
             height: BlockHeight(100),
+            block_hash: CryptoHash::from([0u8; 32]),
+            tx_index: 0,
+            event_pos_in_tx: 0,
             event_index: 0,
             evm_recipient: "0xabcdef1234567890abcdef1234567890abcdef12"
                 .parse()

linera-bridge/src/monitor/evm.rs

@@ -94,8 +94,8 @@ pub(crate) async fn process_pending_deposits<E: linera_core::environment::Enviro
                             log_index,
                         };
                         if let Ok(raw) = bcs::to_bytes(&op) {
-                            if let Err(e) = db.store_deposit_raw(&pending.key, &raw).await {
-                                tracing::warn!(%tx_hash, "Failed to store deposit raw bytes: {e:#}");
+                            if let Err(error) = db.store_deposit_raw(&pending.key, &raw).await {
+                                tracing::warn!(%tx_hash, ?error, "Failed to store deposit raw bytes");
                             }
                         }
                     }
@@ -111,12 +111,16 @@ pub(crate) async fn process_pending_deposits<E: linera_core::environment::Enviro
                     }
                 }
             }
-            Err(e) => {
-                tracing::warn!(%tx_hash, "Proof generation failed: {e:#}");
+            Err(error) => {
+                tracing::warn!(%tx_hash, ?error, "Proof generation failed");
             }
         }
 
-        monitor.write().await.mark_deposit_retried(&pending.key);
+        monitor
+            .write()
+            .await
+            .mark_deposit_retried(&pending.key, max_retries)
+            .await;
     }
 }
 
@@ -163,8 +167,8 @@ async fn evm_scan_iteration(
         };
         let deposit = match parse_deposit_event(&receipt_log, bridge_addr) {
             Ok(d) => d,
-            Err(e) => {
-                tracing::warn!(%tx_hash, "Failed to parse DepositInitiated log: {e:#}");
+            Err(error) => {
+                tracing::warn!(%tx_hash, ?error, "Failed to parse DepositInitiated log");
                 continue;
             }
         };