indexer: Perform Bedrock DB upgrade (#3666)

indexer/db/db.go

@@ -197,6 +197,12 @@ func (d *Database) AddIndexedL1Block(block *IndexedL1Block) error {
 	VALUES
 		($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
 	`
+
+	const updateWithdrawalStatement = `
+	UPDATE withdrawals SET (br_withdrawal_finalized_tx_hash, br_withdrawal_finalized_log_index, br_withdrawal_finalized_success) = ($1, $2, $3)
+	WHERE br_withdrawal_hash = $4
+	`
+
 	return txn(d.db, func(tx *sql.Tx) error {
 		_, err := tx.Exec(
 			insertBlockStatement,
@@ -209,26 +215,39 @@ func (d *Database) AddIndexedL1Block(block *IndexedL1Block) error {
 			return err
 		}
 
-		if len(block.Deposits) == 0 {
-			return nil
+		if len(block.Deposits) > 0 {
+			for _, deposit := range block.Deposits {
+				_, err = tx.Exec(
+					insertDepositStatement,
+					NewGUID(),
+					deposit.FromAddress.String(),
+					deposit.ToAddress.String(),
+					deposit.L1Token.String(),
+					deposit.L2Token.String(),
+					deposit.Amount.String(),
+					deposit.TxHash.String(),
+					deposit.LogIndex,
+					block.Hash.String(),
+					deposit.Data,
+				)
+				if err != nil {
+					return err
+				}
+			}
 		}
 
-		for _, deposit := range block.Deposits {
-			_, err = tx.Exec(
-				insertDepositStatement,
-				NewGUID(),
-				deposit.FromAddress.String(),
-				deposit.ToAddress.String(),
-				deposit.L1Token.String(),
-				deposit.L2Token.String(),
-				deposit.Amount.String(),
-				deposit.TxHash.String(),
-				deposit.LogIndex,
-				block.Hash.String(),
-				deposit.Data,
-			)
-			if err != nil {
-				return err
+		if len(block.FinalizedWithdrawals) > 0 {
+			for _, wd := range block.FinalizedWithdrawals {
+				_, err = tx.Exec(
+					updateWithdrawalStatement,
+					wd.TxHash.String(),
+					wd.LogIndex,
+					wd.Success,
+					wd.WithdrawalHash.String(),
+				)
+				if err != nil {
+					return err
+				}
 			}
 		}
 
@@ -459,19 +478,21 @@ func (d *Database) GetWithdrawalBatch(hash common.Hash) (*StateBatchJSON, error)
 
 // GetWithdrawalsByAddress returns the list of Withdrawals indexed for the given
 // address paginated by the given params.
-func (d *Database) GetWithdrawalsByAddress(address common.Address, page PaginationParam) (*PaginatedWithdrawals, error) {
+func (d *Database) GetWithdrawalsByAddress(address common.Address, page PaginationParam, state FinalizationState) (*PaginatedWithdrawals, error) {
 	selectWithdrawalsStatement := fmt.Sprintf(`
 	SELECT
 	    withdrawals.guid, withdrawals.from_address, withdrawals.to_address,
 		withdrawals.amount, withdrawals.tx_hash, withdrawals.data,
 		withdrawals.l1_token, withdrawals.l2_token,
 		l2_tokens.name, l2_tokens.symbol, l2_tokens.decimals,
-		l2_blocks.number, l2_blocks.timestamp, withdrawals.br_withdrawal_hash
+		l2_blocks.number, l2_blocks.timestamp, withdrawals.br_withdrawal_hash,
+		withdrawals.br_withdrawal_finalized_tx_hash, withdrawals.br_withdrawal_finalized_log_index,
+		withdrawals.br_withdrawal_finalized_success
 	FROM withdrawals
 		INNER JOIN l2_blocks ON withdrawals.block_hash=l2_blocks.hash
 		INNER JOIN l2_tokens ON withdrawals.l2_token=l2_tokens.address
 	WHERE withdrawals.from_address = $1 %s ORDER BY l2_blocks.timestamp LIMIT $2 OFFSET $3;
-	`, FinalizationStateAny.SQL())
+	`, state.SQL())
 	var withdrawals []WithdrawalJSON
 
 	err := txn(d.db, func(tx *sql.Tx) error {
@@ -485,13 +506,16 @@ func (d *Database) GetWithdrawalsByAddress(address common.Address, page Paginati
 			var withdrawal WithdrawalJSON
 			var l2Token Token
 			var wdHash sql.NullString
+			var finTxHash sql.NullString
+			var finLogIndex sql.NullInt32
+			var finSuccess sql.NullBool
 			if err := rows.Scan(
 				&withdrawal.GUID, &withdrawal.FromAddress, &withdrawal.ToAddress,
 				&withdrawal.Amount, &withdrawal.TxHash, &withdrawal.Data,
 				&withdrawal.L1Token, &l2Token.Address,
 				&l2Token.Name, &l2Token.Symbol, &l2Token.Decimals,
 				&withdrawal.BlockNumber, &withdrawal.BlockTimestamp,
-				&wdHash,
+				&wdHash, &finTxHash, &finLogIndex, &finSuccess,
 			); err != nil {
 				return err
 			}
@@ -499,6 +523,16 @@ func (d *Database) GetWithdrawalsByAddress(address common.Address, page Paginati
 			if wdHash.Valid {
 				withdrawal.BedrockWithdrawalHash = &wdHash.String
 			}
+			if finTxHash.Valid {
+				withdrawal.BedrockFinalizedTxHash = &finTxHash.String
+			}
+			if finLogIndex.Valid {
+				idx := int(finLogIndex.Int32)
+				withdrawal.BedrockFinalizedLogIndex = &idx
+			}
+			if finSuccess.Valid {
+				withdrawal.BedrockFinalizedSuccess = &finSuccess.Bool
+			}
 			withdrawals = append(withdrawals, withdrawal)
 		}
 

indexer/db/l1block.go

@@ -6,11 +6,12 @@ import (
 
 // IndexedL1Block contains the L1 block including the deposits in it.
 type IndexedL1Block struct {
-	Hash       common.Hash
-	ParentHash common.Hash
-	Number     uint64
-	Timestamp  uint64
-	Deposits   []Deposit
+	Hash                 common.Hash
+	ParentHash           common.Hash
+	Number               uint64
+	Timestamp            uint64
+	Deposits             []Deposit
+	FinalizedWithdrawals []FinalizedWithdrawal
 }
 
 // String returns the block hash for the indexed l1 block.

indexer/db/sql.go

@@ -125,8 +125,8 @@ CREATE TABLE IF NOT EXISTS airdrops (
 const updateWithdrawalsTable = `
 ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_hash VARCHAR NULL;
 ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_finalized_tx_hash VARCHAR NULL;
-ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_finalized_log_index BOOLEAN NULL;
-ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_success BOOLEAN NULL;
+ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_finalized_log_index INTEGER NULL;
+ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_finalized_success BOOLEAN NULL;
 CREATE INDEX IF NOT EXISTS withdrawals_br_withdrawal_hash ON withdrawals(br_withdrawal_hash);
 `
 

indexer/db/withdrawal.go

@@ -27,19 +27,22 @@ func (w Withdrawal) String() string {
 
 // WithdrawalJSON contains Withdrawal data suitable for JSON serialization.
 type WithdrawalJSON struct {
-	GUID                  string          `json:"guid"`
-	FromAddress           string          `json:"from"`
-	ToAddress             string          `json:"to"`
-	L1Token               string          `json:"l1Token"`
-	L2Token               *Token          `json:"l2Token"`
-	Amount                string          `json:"amount"`
-	Data                  []byte          `json:"data"`
-	LogIndex              uint64          `json:"logIndex"`
-	BlockNumber           uint64          `json:"blockNumber"`
-	BlockTimestamp        string          `json:"blockTimestamp"`
-	TxHash                string          `json:"transactionHash"`
-	Batch                 *StateBatchJSON `json:"batch"`
-	BedrockWithdrawalHash *string         `json:"bedrockWithdrawalHash"`
+	GUID                     string          `json:"guid"`
+	FromAddress              string          `json:"from"`
+	ToAddress                string          `json:"to"`
+	L1Token                  string          `json:"l1Token"`
+	L2Token                  *Token          `json:"l2Token"`
+	Amount                   string          `json:"amount"`
+	Data                     []byte          `json:"data"`
+	LogIndex                 uint64          `json:"logIndex"`
+	BlockNumber              uint64          `json:"blockNumber"`
+	BlockTimestamp           string          `json:"blockTimestamp"`
+	TxHash                   string          `json:"transactionHash"`
+	Batch                    *StateBatchJSON `json:"batch"`
+	BedrockWithdrawalHash    *string         `json:"bedrockWithdrawalHash"`
+	BedrockFinalizedTxHash   *string         `json:"bedrockFinalizedTxHash"`
+	BedrockFinalizedLogIndex *int            `json:"bedrockFinalizedLogIndex"`
+	BedrockFinalizedSuccess  *bool           `json:"bedrockFinalizedSuccess"`
 }
 
 type FinalizationState int
@@ -64,9 +67,9 @@ func ParseFinalizationState(in string) FinalizationState {
 func (f FinalizationState) SQL() string {
 	switch f {
 	case FinalizationStateFinalized:
-		return "AND withdrawals.l1_block_hash IS NOT NULL"
+		return "AND withdrawals.br_withdrawal_finalized_tx_hash IS NOT NULL"
 	case FinalizationStateUnfinalized:
-		return "AND withdrawals.l2_block_hash IS NULL"
+		return "AND withdrawals.br_withdrawal_finalized_tx_hash IS NULL"
 	}
 
 	return ""

indexer/services/l2/service.go

@@ -385,7 +385,7 @@ func (s *Service) GetWithdrawals(w http.ResponseWriter, r *http.Request) {
 		Offset: uint64(offset),
 	}
 
-	withdrawals, err := s.cfg.DB.GetWithdrawalsByAddress(common.HexToAddress(vars["address"]), page)
+	withdrawals, err := s.cfg.DB.GetWithdrawalsByAddress(common.HexToAddress(vars["address"]), page, db.FinalizationStateAny)
 	if err != nil {
 		server.RespondWithError(w, http.StatusInternalServerError, err.Error())
 		return