simplify scripts and remove duplicate code

jonastheis · jonastheis · commit 08b0f0f52c42 · 2025-09-23T19:59:49.000+08:00
diff --git a/sequencer-migration/common-functions.sh b/sequencer-migration/common-functions.sh
@@ -139,13 +139,22 @@ disable_l2reth_sequencing() {
 }
 
 # Wait for a specific block to be reached
+# Parameters:
+#   $1: node_name - Human readable name for logging
+#   $2: rpc_url - RPC URL to query
+#   $3: target_block - Block number to wait for
+#   $4: target_hash (optional) - If provided, will verify exact hash match
 wait_for_block() {
     local node_name="$1"
     local rpc_url="$2"
     local target_block="$3"
     local target_hash="$4"
 
-    log_info "Waiting for $node_name to reach block #$target_block (hash: $target_hash)..."
+    if [[ -n "$target_hash" ]]; then
+        log_info "Waiting for $node_name to reach block #$target_block (hash: $target_hash)..."
+    else
+        log_info "Waiting for $node_name to reach block #$target_block or higher..."
+    fi
 
     local start_time=$(date +%s)
     while true; do
@@ -156,9 +165,11 @@ wait_for_block() {
         if [[ $elapsed -gt $SYNC_TIMEOUT ]]; then
             log_error "Timeout waiting for $node_name to reach block #$target_block"
 
-            local current_block=$(echo "$block_info" | awk '{print $1}')
-            local current_hash=$(echo "$block_info" | awk '{print $2}')
-            log_error "$node_name is at block $current_block (hash: $current_hash)"
+            if block_info=$(get_latest_block_info "$rpc_url" 2>/dev/null); then
+                local current_block=$(echo "$block_info" | awk '{print $1}')
+                local current_hash=$(echo "$block_info" | awk '{print $2}')
+                log_error "$node_name is at block $current_block (hash: $current_hash)"
+            fi
 
             return 1
         fi
@@ -169,14 +180,21 @@ wait_for_block() {
             local current_hash=$(echo "$block_info" | awk '{print $2}')
 
             if [[ "$current_block" -ge "$target_block" ]]; then
-                if [[ "$current_block" -eq "$target_block" && "$current_hash" == "$target_hash" ]]; then
-                    log_success "$node_name reached target block #$target_block (hash: $target_hash)"
-                    return 0
-                elif [[ "$current_block" -gt "$target_block" ]]; then
-                    log_success "$node_name surpassed target, now at block #$current_block (hash: $current_hash)"
-                    return 0
+                if [[ -n "$target_hash" ]]; then
+                    # Hash verification mode
+                    if [[ "$current_block" -eq "$target_block" && "$current_hash" == "$target_hash" ]]; then
+                        log_success "$node_name reached target block #$target_block (hash: $target_hash)"
+                        return 0
+                    elif [[ "$current_block" -gt "$target_block" ]]; then
+                        log_success "$node_name surpassed target, now at block #$current_block (hash: $current_hash)"
+                        return 0
+                    else
+                        log_warning "$node_name at block #$current_block but hash mismatch: expected $target_hash, got $current_hash"
+                    fi
                 else
-                    log_warning "$node_name at block #$current_block but hash mismatch: expected $target_hash, got $current_hash"
+                    # Block number only mode
+                    log_success "$node_name reached block #$current_block (hash: $current_hash)"
+                    return 0
                 fi
             fi
         fi
diff --git a/sequencer-migration/migrate-sequencer.sh b/sequencer-migration/migrate-sequencer.sh
@@ -158,30 +158,13 @@ main() {
     log_info "=== PHASE 6: RESUMING L2GETH SEQUENCING ==="
     start_l2geth_mining
 
-    # TODO: change wait for method so that this can be done as well. 
-    # Wait for at least one new block to confirm
-    log_info "Waiting for L2GETH to produce at least one new block..."
+    # Wait for at least one new block to confirm sequencing resumed
     local confirmation_target=$((L2RETH_FINAL_BLOCK + 1))
-    local start_time=$(date +%s)
-    while true; do
-        local current_time=$(date +%s)
-        local elapsed=$((current_time - start_time))
-
-        if [[ $elapsed -gt 5 ]]; then  # 5 seconds timeout for first block
-            log_error "Timeout waiting for L2GETH to produce new block"
-            exit 1
-        fi
-
-        local current_block=$(get_block_number "$L2GETH_RPC_URL")
-        if [[ $current_block -ge $confirmation_target ]]; then
-            local confirm_info=$(get_latest_block_info "$L2GETH_RPC_URL")
-            local confirm_hash=$(echo "$confirm_info" | awk '{print $2}')
-            log_success "L2GETH sequencing resumed, produced block #$current_block (hash: $confirm_hash)"
-            break
-        fi
-
-        sleep $POLL_INTERVAL
-    done
+    if ! wait_for_block "L2GETH" "$L2GETH_RPC_URL" "$confirmation_target" ""; then
+        log_error "L2GETH failed to produce new block after resuming sequencing"
+        exit 1
+    fi
+    log_success "L2GETH sequencing resumed successfully"
 
     print_summary
 }
diff --git a/sequencer-migration/revert-l2geth-to-block.sh b/sequencer-migration/revert-l2geth-to-block.sh
@@ -9,9 +9,6 @@ set -euo pipefail
 # Source common functions
 source "$(dirname "$0")/common-functions.sh"
 
-# Script-specific configuration
-BLOCK_PRODUCTION_TIMEOUT=60  # 60 seconds timeout for new block production
-
 # Global variables to track state
 START_TIME=$(date +%s)
 TARGET_BLOCK=""
@@ -35,34 +32,6 @@ reset_l2geth_to_block() {
     fi
 }
 
-# Wait for new block production after reset
-wait_for_new_block_production() {
-    local starting_block="$1"
-    local expected_next_block=$((starting_block + 1))
-
-    log_info "Waiting for l2geth to produce new blocks starting from #$expected_next_block..."
-
-    local start_time=$(date +%s)
-    while true; do
-        local current_time=$(date +%s)
-        local elapsed=$((current_time - start_time))
-
-        if [[ $elapsed -gt $BLOCK_PRODUCTION_TIMEOUT ]]; then
-            log_error "Timeout waiting for l2geth to produce new block (waited ${BLOCK_PRODUCTION_TIMEOUT}s)"
-            return 1
-        fi
-
-        local current_block=$(get_block_number "$L2GETH_RPC_URL")
-        if [[ $current_block -ge $expected_next_block ]]; then
-            local block_info=$(get_latest_block_info "$L2GETH_RPC_URL")
-            local block_hash=$(echo "$block_info" | awk '{print $2}')
-            log_success "L2GETH produced new block #$current_block (hash: $block_hash)"
-            return 0
-        fi
-
-        sleep $POLL_INTERVAL
-    done
-}
 
 
 pre_flight_checks() {
@@ -193,8 +162,11 @@ main() {
 
     # Phase 5: Wait for new block production
     log_info "=== PHASE 5: MONITORING NEW BLOCK PRODUCTION ==="
-    # TODO: combine with wait_for_block ?
-    wait_for_new_block_production "$TARGET_BLOCK"
+    local expected_next_block=$((TARGET_BLOCK + 1))
+    if ! wait_for_block "L2GETH" "$L2GETH_RPC_URL" "$expected_next_block" ""; then
+        log_error "L2GETH failed to produce new block after reset"
+        exit 1
+    fi
 
     print_summary
 }
diff --git a/tests/tests/migrate_sequencer.rs b/tests/tests/migrate_sequencer.rs
@@ -1,46 +1,6 @@
 use eyre::Result;
 use tests::*;
 
-///
-/// This integration test validates that blocks can be successfully propagated between
-/// different Ethereum client implementations (l2geth and rollup-node) in various
-/// network topologies. The test exercises:
-///
-/// 1. **Isolated Network Segments**: Initially runs l2geth nodes in isolation, verifying they can
-///    produce and sync blocks independently
-///    - Topology: `l2geth_follower -> l2geth_sequencer`
-///    - l2geth_sequencer produces blocks, l2geth_follower syncs
-///    - Rollup nodes remain disconnected at block 0
-///
-/// 2. **Cross-Client Synchronization**: Connects rollup nodes to the l2geth network, ensuring they
-///    can catch up to the current chain state
-///    - Topology: `[rn_follower, rn_sequencer, l2geth_follower] -> l2geth_sequencer`
-///    - All nodes connect to l2geth_sequencer as the single source of truth
-///    - Rollup nodes sync from block 0 to current height
-///
-/// 3. **Sequencer Handoff**: Transitions block production from l2geth to rollup-node, testing that
-///    all nodes stay synchronized during the transition
-///    - Topology remains: `[rn_follower, rn_sequencer, l2geth_follower] -> l2geth_sequencer`
-///    - Block production switches from l2geth_sequencer to rn_sequencer
-///    - All nodes receive new blocks from rn_sequencer via l2geth_sequencer relay
-///
-/// 4. **Network Partition Recovery**: Disconnects l2geth nodes, continues production on rollup
-///    nodes, then reconnects to verify successful resynchronization
-///    - Initial partition: `rn_follower -> rn_sequencer` (isolated rollup network)
-///    - l2geth nodes disconnected, fall behind in block height
-///    - Reconnection topology: `[l2geth_follower, l2geth_sequencer] -> rn_sequencer`
-///    - l2geth nodes catch up by syncing from rn_sequencer
-///
-/// 5. **Bidirectional Compatibility**: Returns block production to l2geth after rollup nodes have
-///    extended the chain, ensuring backward compatibility
-///    - Final topology: `[rn_follower, l2geth_follower, l2geth_sequencer] -> rn_sequencer`
-///    - Block production returns to l2geth_sequencer
-///    - Validates that l2geth can continue the chain after rollup node blocks
-///
-/// The test validates that both client implementations maintain consensus despite
-/// network topology changes, sequencer transitions, and temporary network partitions.
-/// Each topology change tests different aspects of peer discovery, block gossip,
-/// and chain synchronization across heterogeneous client implementations.
 #[tokio::test]
 async fn docker_test_migrate_sequencer() -> Result<()> {
     reth_tracing::init_test_tracing();
