Fix reorg backward let (#890)

* deposit_backup table

* query

* ctx

* restore deposits when backwardLet is reorged

* fix test + mocks

* linter

Author: ARR552

bridgectrl/merkletree_test.go

@@ -169,7 +169,7 @@ func TestMTGetProof(t *testing.T) {
 					BlockNumber: uint64(li + 1), // nolint:gosec
 					BlockHash:   common.HexToHash("0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9fc"),
 				}
-				blockID, err := testStore.AddBlock(context.TODO(), block, nil)
+				blockID, err := testStore.AddBlock(ctx, block, nil)
 				require.NoError(t, err)
 				deposit := &etherman.Deposit{
 					OriginalNetwork:    leaf.OriginalNetwork,

db/pgstorage/migrations/0022.sql

@@ -0,0 +1,29 @@
+-- +migrate Up
+
+CREATE TABLE IF NOT EXISTS sync.deposit_backup
+(
+    leaf_type   INTEGER,
+    network_id  BIGINT,
+    orig_net    BIGINT,
+    orig_addr   BYTEA NOT NULL,
+    amount      VARCHAR,
+    dest_net    BIGINT NOT NULL,
+    dest_addr   BYTEA NOT NULL,
+    block_id    BIGINT REFERENCES sync.block (id) ON DELETE CASCADE,
+    deposit_cnt BIGINT,
+    tx_hash     BYTEA NOT NULL,
+    metadata    BYTEA NOT NULL,
+    id          BIGSERIAL,
+    ready_for_claim BOOLEAN DEFAULT false NOT NULL,
+    backward_let_id BIGINT NOT NULL,
+    PRIMARY KEY (id)
+);
+
+-- Add index on backward_let_id for faster orphan lookups and JOIN operations
+CREATE INDEX IF NOT EXISTS idx_deposit_backup_backward_let_id
+ON sync.deposit_backup(backward_let_id);
+
+-- +migrate Down
+
+DROP INDEX IF EXISTS sync.idx_deposit_backup_backward_let_id;
+DROP TABLE IF EXISTS sync.deposit_backup;

db/pgstorage/migrations/0022_test.go

@@ -0,0 +1,83 @@
+package migrations_test
+
+import (
+	"database/sql"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type migrationTest0022 struct{}
+
+func (m migrationTest0022) InsertData(db *sql.DB) error {
+	block := "INSERT INTO sync.block (id, block_num, block_hash, network_id) VALUES(1, 1, decode('C9B5033799ADF3739383A0489EFBE8A0D4D5E4478778A4F4304562FD51AE4C07','hex'), 0);"
+	if _, err := db.Exec(block); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m migrationTest0022) RunAssertsAfterMigrationUp(t *testing.T, db *sql.DB) {
+	insertDepositBackup := `INSERT INTO sync.deposit_backup(leaf_type, network_id, orig_net, orig_addr, amount, dest_net, dest_addr, block_id, deposit_cnt, tx_hash, metadata, ready_for_claim, backward_let_id)
+		VALUES(0, 1, 0, decode('A9B5033799ADF3739383A0489EFBE8A0D4D5E4478778A4F4304562FD51AE4C08','hex'), '1000000000000000000', 1, decode('B9B5033799ADF3739383A0489EFBE8A0D4D5E4478778A4F4304562FD51AE4C09','hex'), 1, 5, decode('C9B5033799ADF3739383A0489EFBE8A0D4D5E4478778A4F4304562FD51AE4C10','hex'), decode('D9B5033799ADF3739383A0489EFBE8A0D4D5E4478778A4F4304562FD51AE4C11','hex'), true, 1);`
+	_, err := db.Exec(insertDepositBackup)
+	assert.NoError(t, err)
+
+	var count uint32
+	selectCount := "SELECT count(*) FROM sync.deposit_backup"
+	err = db.QueryRow(selectCount).Scan(&count)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(1), count)
+
+	// Verify the data was inserted correctly
+	var leafType, networkID, origNet, destNet, depositCnt, backwardLetID int64
+	var amount string
+	var readyForClaim bool
+	selectData := "SELECT leaf_type, network_id, orig_net, amount, dest_net, deposit_cnt, ready_for_claim, backward_let_id FROM sync.deposit_backup WHERE id = 1"
+	err = db.QueryRow(selectData).Scan(&leafType, &networkID, &origNet, &amount, &destNet, &depositCnt, &readyForClaim, &backwardLetID)
+	assert.NoError(t, err)
+	assert.Equal(t, int64(0), leafType)
+	assert.Equal(t, int64(1), networkID)
+	assert.Equal(t, int64(0), origNet)
+	assert.Equal(t, "1000000000000000000", amount)
+	assert.Equal(t, int64(1), destNet)
+	assert.Equal(t, int64(5), depositCnt)
+	assert.Equal(t, true, readyForClaim)
+	assert.Equal(t, int64(1), backwardLetID)
+
+	// Verify the index was created
+	var indexExists bool
+	checkIndex := `SELECT EXISTS (
+		SELECT 1 FROM pg_indexes
+		WHERE schemaname = 'sync'
+		AND tablename = 'deposit_backup'
+		AND indexname = 'idx_deposit_backup_backward_let_id'
+	)`
+	err = db.QueryRow(checkIndex).Scan(&indexExists)
+	assert.NoError(t, err)
+	assert.True(t, indexExists, "Index idx_deposit_backup_backward_let_id should exist")
+}
+
+func (m migrationTest0022) RunAssertsAfterMigrationDown(t *testing.T, db *sql.DB) {
+	// Verify the table was dropped
+	var count uint32
+	selectCount := "SELECT count(*) FROM sync.deposit_backup"
+	err := db.QueryRow(selectCount).Scan(&count)
+	assert.Error(t, err)
+
+	// Verify the index was also removed
+	var indexExists bool
+	checkIndex := `SELECT EXISTS (
+		SELECT 1 FROM pg_indexes
+		WHERE schemaname = 'sync'
+		AND tablename = 'deposit_backup'
+		AND indexname = 'idx_deposit_backup_backward_let_id'
+	)`
+	err = db.QueryRow(checkIndex).Scan(&indexExists)
+	assert.NoError(t, err)
+	assert.False(t, indexExists, "Index idx_deposit_backup_backward_let_id should not exist after migration down")
+}
+
+func TestMigration0022(t *testing.T) {
+	runMigrationTest(t, 22, migrationTest0022{})
+}

db/pgstorage/pgstorage.go

@@ -922,22 +922,47 @@ func (p *PostgresStorage) GetSyncStatus(ctx context.Context, dbTx interface{}) (
 }
 
 // ResetDeposits resets the state to a depositCount.
-func (p *PostgresStorage) ResetDeposits(ctx context.Context, depositCount uint32, networkID uint32, dbTx interface{}) error {
+func (p *PostgresStorage) ResetDeposits(ctx context.Context, depositCount uint32, networkID uint32, backwardLETID uint64, dbTx interface{}) error {
 	if networkID == 0 {
 		return errors.New("cannot reset L1 deposits")
 	}
-	const resetSQL = "DELETE FROM sync.deposit WHERE deposit_cnt >= $1 AND network_id = $2"
+	// Store the deposits in other table and remove from deposit table
+	// Using CTE to ensure deposits are returned in ascending order by deposit_cnt
+	const resetSQL = `
+		WITH deleted_deposits AS (
+			DELETE FROM sync.deposit
+			WHERE deposit_cnt >= $1 AND network_id = $2
+			RETURNING id, leaf_type, orig_net, orig_addr, amount, dest_net, dest_addr, deposit_cnt, block_id, network_id, tx_hash, metadata, ready_for_claim
+		)
+		SELECT id, leaf_type, orig_net, orig_addr, amount, dest_net, dest_addr, deposit_cnt, block_id, network_id, tx_hash, metadata, ready_for_claim
+		FROM deleted_deposits
+		ORDER BY deposit_cnt ASC`
 	e := p.getExecQuerier(dbTx)
-	_, err := e.Exec(ctx, resetSQL, depositCount, networkID)
-	return err
+	rows, err := e.Query(ctx, resetSQL, depositCount, networkID)
+    if err != nil {
+        return err
+    }
+    defer rows.Close()
+	deposits, err := parseDeposits(rows, false)
+	if err != nil {
+		return err
+	}
+	const addDepositSQL = "INSERT INTO sync.deposit_backup (leaf_type, network_id, orig_net, orig_addr, amount, dest_net, dest_addr, block_id, deposit_cnt, tx_hash, metadata, ready_for_claim, backward_let_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)"
+	for _, deposit := range deposits {
+		_, err = e.Exec(ctx, addDepositSQL, deposit.LeafType, deposit.NetworkID, deposit.OriginalNetwork, deposit.OriginalAddress, deposit.Amount.String(), deposit.DestinationNetwork, deposit.DestinationAddress, deposit.BlockID, deposit.DepositCount, deposit.TxHash, deposit.Metadata, deposit.ReadyForClaim, backwardLETID)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 // AddBackwardLET adds a new BackwardLET event to the db.
-func (p *PostgresStorage) AddBackwardLET(ctx context.Context, backwardLET *etherman.BackwardLET, dbTx interface{}) error {
-	const addExitRootSQL = "INSERT INTO sync.backward_let(block_id, previous_deposit_cnt, previous_root, new_deposit_cnt, new_root) VALUES ($1, $2, $3, $4, $5)"
-	e := p.getExecQuerier(dbTx)
-	_, err := e.Exec(ctx, addExitRootSQL, backwardLET.BlockID, backwardLET.PreviousDepositCount, backwardLET.PreviousRoot, backwardLET.NewDepositCount, backwardLET.NewRoot)
-	return err
+func (p *PostgresStorage) AddBackwardLET(ctx context.Context, backwardLET *etherman.BackwardLET, dbTx interface{}) (uint64, error) {
+	const addExitRootSQL = "INSERT INTO sync.backward_let(block_id, previous_deposit_cnt, previous_root, new_deposit_cnt, new_root) VALUES ($1, $2, $3, $4, $5) RETURNING id"
+	var id uint64
+	err := p.getExecQuerier(dbTx).QueryRow(ctx, addExitRootSQL, backwardLET.BlockID, backwardLET.PreviousDepositCount, backwardLET.PreviousRoot, backwardLET.NewDepositCount, backwardLET.NewRoot).Scan(&id)
+	return id, err
 }
 
 // AddForwardLET adds a new ForwardLET event to the db.
@@ -983,6 +1008,37 @@ func (p *PostgresStorage) GetLastComputedRoot(ctx context.Context, networkID uin
 	return root, nil
 }
 
+// GetAndDeleteOrphanDepositBackups finds and deletes deposit_backup records whose backward_let_id
+// does not exist in the backward_let table, returning the deleted deposits.
+// This uses a single optimized DELETE query with RETURNING clause and LEFT JOIN for better performance.
+func (p *PostgresStorage) GetAndDeleteOrphanDepositBackups(ctx context.Context, dbTx interface{}) ([]*etherman.Deposit, error) {
+	// Single query that deletes orphan deposits and returns them in one operation
+	// Using LEFT JOIN with NULL check is often faster than NOT EXISTS for this use case
+	const deleteAndReturnOrphanDepositsSQL = `
+		DELETE FROM sync.deposit_backup AS db
+		USING (
+			SELECT db2.id
+			FROM sync.deposit_backup AS db2
+			LEFT JOIN sync.backward_let AS bl ON bl.id = db2.backward_let_id
+			WHERE bl.id IS NULL
+			ORDER BY db2.deposit_cnt ASC
+		) AS orphans
+		WHERE db.id = orphans.id
+		RETURNING db.id, db.leaf_type, db.orig_net, db.orig_addr, db.amount, db.dest_net,
+		          db.dest_addr, db.deposit_cnt, db.block_id, db.network_id, db.tx_hash,
+		          db.metadata, db.ready_for_claim`
+
+	e := p.getExecQuerier(dbTx)
+	rows, err := e.Query(ctx, deleteAndReturnOrphanDepositsSQL)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	// Parse and return the deleted deposits
+	return parseDeposits(rows, false)
+}
+
 // UpdateDepositsStatusForTesting updates the ready_for_claim status of all deposits for testing.
 func (p *PostgresStorage) UpdateDepositsStatusForTesting(ctx context.Context, dbTx interface{}) error {
 	const updateDepositsStatusSQL = "UPDATE sync.deposit SET ready_for_claim = true;"