indexer: update finalizations

indexer/db/db.go

@@ -193,10 +193,20 @@ func (d *Database) AddIndexedL1Block(block *IndexedL1Block) error {
 
 	const insertDepositStatement = `
 	INSERT INTO deposits
-		(guid, from_address, to_address, l1_token, l2_token, amount, tx_hash, log_index, block_hash, data)
+		(guid, from_address, to_address, l1_token, l2_token, amount, tx_hash, log_index, l1_block_hash, data)
 	VALUES
 		($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
 	`
+
+	const insertWithdrawalStatement = `
+	INSERT INTO withdrawals
+		(guid, from_address, to_address, l1_token, l2_token, amount, tx_hash, log_index, l1_block_hash, data)
+	VALUES
+		($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+	ON CONFLICT (tx_hash)
+		DO UPDATE SET l1_block_hash = $9;
+	`
+
 	return txn(d.db, func(tx *sql.Tx) error {
 		_, err := tx.Exec(
 			insertBlockStatement,
@@ -232,6 +242,29 @@ func (d *Database) AddIndexedL1Block(block *IndexedL1Block) error {
 			}
 		}
 
+		if len(block.Withdrawals) == 0 {
+			return nil
+		}
+
+		for _, withdrawal := range block.Withdrawals {
+			_, err = tx.Exec(
+				insertWithdrawalStatement,
+				NewGUID(),
+				withdrawal.FromAddress.String(),
+				withdrawal.ToAddress.String(),
+				withdrawal.L1Token.String(),
+				withdrawal.L2Token.String(),
+				withdrawal.Amount.String(),
+				withdrawal.TxHash.String(),
+				withdrawal.LogIndex,
+				block.Hash.String(),
+				withdrawal.Data,
+			)
+			if err != nil {
+				return err
+			}
+		}
+
 		return nil
 	})
 }
@@ -249,7 +282,7 @@ func (d *Database) AddIndexedL2Block(block *IndexedL2Block) error {
 
 	const insertWithdrawalStatement = `
 	INSERT INTO withdrawals
-		(guid, from_address, to_address, l1_token, l2_token, amount, tx_hash, log_index, block_hash, data)
+		(guid, from_address, to_address, l1_token, l2_token, amount, tx_hash, log_index, l2_block_hash, data)
 	VALUES
 		($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
 	`
@@ -303,7 +336,7 @@ func (d *Database) GetDepositsByAddress(address common.Address, page PaginationP
 		l1_tokens.name, l1_tokens.symbol, l1_tokens.decimals,
 		l1_blocks.number, l1_blocks.timestamp
 	FROM deposits
-		INNER JOIN l1_blocks ON deposits.block_hash=l1_blocks.hash
+		INNER JOIN l1_blocks ON deposits.l1_block_hash=l1_blocks.hash
 		INNER JOIN l1_tokens ON deposits.l1_token=l1_tokens.address
 	WHERE deposits.from_address = $1 ORDER BY l1_blocks.timestamp LIMIT $2 OFFSET $3;
 	`
@@ -342,7 +375,7 @@ func (d *Database) GetDepositsByAddress(address common.Address, page PaginationP
 	SELECT
 		count(*)
 	FROM deposits
-		INNER JOIN l1_blocks ON deposits.block_hash=l1_blocks.hash
+		INNER JOIN l1_blocks ON deposits.l1_block_hash=l1_blocks.hash
 		INNER JOIN l1_tokens ON deposits.l1_token=l1_tokens.address
 	WHERE deposits.from_address = $1;
 	`
@@ -368,6 +401,53 @@ func (d *Database) GetDepositsByAddress(address common.Address, page PaginationP
 	}, nil
 }
 
+// GetWithdrawalStatus returns the finalization status corresponding to the
+// given withdrawal transaction hash.
+func (d *Database) GetWithdrawalStatus(hash common.Hash) (*WithdrawalJSON, error) {
+	const selectWithdrawalStatement = `
+	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,
+		l1_blocks.number, l1_blocks.timestamp,
+		l2_blocks.number, l2_blocks.timestamp
+	FROM withdrawals
+		INNER JOIN l1_blocks ON withdrawals.l1_block_hash=l1_blocks.hash
+		INNER JOIN l2_blocks ON withdrawals.l2_block_hash=l2_blocks.hash
+		INNER JOIN l2_tokens ON withdrawals.l2_token=l2_tokens.address
+	WHERE withdrawals.tx_hash = $1;
+	`
+
+	var withdrawal *WithdrawalJSON
+	err := txn(d.db, func(tx *sql.Tx) error {
+		row := tx.QueryRow(selectWithdrawalStatement, hash.String())
+		if row.Err() != nil {
+			return row.Err()
+		}
+
+		var l2Token Token
+		if err := row.Scan(
+			&withdrawal.GUID, &withdrawal.FromAddress, &withdrawal.ToAddress,
+			&withdrawal.Amount, &withdrawal.TxHash, &withdrawal.Data,
+			&withdrawal.L1Token, &l2Token.Address,
+			&l2Token.Name, &l2Token.Symbol, &l2Token.Decimals,
+			&withdrawal.L1BlockNumber, &withdrawal.L1BlockTimestamp,
+			&withdrawal.L2BlockNumber, &withdrawal.L2BlockTimestamp,
+		); err != nil {
+			return err
+		}
+		withdrawal.L2Token = &l2Token
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return withdrawal, nil
+}
+
 // 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) {
@@ -379,7 +459,7 @@ func (d *Database) GetWithdrawalsByAddress(address common.Address, page Paginati
 		l2_tokens.name, l2_tokens.symbol, l2_tokens.decimals,
 		l2_blocks.number, l2_blocks.timestamp
 	FROM withdrawals
-		INNER JOIN l2_blocks ON withdrawals.block_hash=l2_blocks.hash
+		INNER JOIN l2_blocks ON withdrawals.l2_block_hash=l2_blocks.hash
 		INNER JOIN l2_tokens ON withdrawals.l2_token=l2_tokens.address
 	WHERE withdrawals.from_address = $1 ORDER BY l2_blocks.timestamp LIMIT $2 OFFSET $3;
 	`
@@ -400,7 +480,7 @@ func (d *Database) GetWithdrawalsByAddress(address common.Address, page Paginati
 				&withdrawal.Amount, &withdrawal.TxHash, &withdrawal.Data,
 				&withdrawal.L1Token, &l2Token.Address,
 				&l2Token.Name, &l2Token.Symbol, &l2Token.Decimals,
-				&withdrawal.BlockNumber, &withdrawal.BlockTimestamp,
+				&withdrawal.L2BlockNumber, &withdrawal.L2BlockTimestamp,
 			); err != nil {
 				return err
 			}
@@ -419,7 +499,7 @@ func (d *Database) GetWithdrawalsByAddress(address common.Address, page Paginati
 	SELECT
 		count(*)
 	FROM withdrawals
-		INNER JOIN l2_blocks ON withdrawals.block_hash=l2_blocks.hash
+		INNER JOIN l2_blocks ON withdrawals.l2_block_hash=l2_blocks.hash
 		INNER JOIN l2_tokens ON withdrawals.l2_token=l2_tokens.address
 	WHERE withdrawals.from_address = $1;
 	`
@@ -567,9 +647,9 @@ func (d *Database) GetIndexedL1BlockByHash(hash common.Hash) (*IndexedL1Block, e
 }
 
 const getAirdropQuery = `
-SELECT 
+SELECT
 	address, voter_amount, multisig_signer_amount, gitcoin_amount,
-	active_bridged_amount, op_user_amount, op_repeat_user_amount, 
+	active_bridged_amount, op_user_amount, op_repeat_user_amount,
     bonus_amount, total_amount
 FROM airdrops
 WHERE address = $1

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
+	Withdrawals []Withdrawal
 }
 
 // String returns the block hash for the indexed l1 block.
@@ -24,6 +25,7 @@ type IndexedL2Block struct {
 	ParentHash  common.Hash
 	Number      uint64
 	Timestamp   uint64
+	Deposits    []Deposit
 	Withdrawals []Withdrawal
 }
 

indexer/db/sql.go

@@ -28,8 +28,10 @@ CREATE TABLE IF NOT EXISTS deposits (
 	amount VARCHAR NOT NULL,
 	data BYTEA NOT NULL,
 	log_index INTEGER NOT NULL,
-	block_hash VARCHAR NOT NULL REFERENCES l1_blocks(hash),
-	tx_hash VARCHAR NOT NULL
+	l1_block_hash VARCHAR NOT NULL REFERENCES l1_blocks(hash),
+	l2_block_hash VARCHAR REFERENCES l2_blocks(hash),
+	tx_hash VARCHAR NOT NULL,
+	failed BOOLEAN NOT NULL DEFAULT false
 )
 `
 
@@ -61,7 +63,8 @@ CREATE TABLE IF NOT EXISTS withdrawals (
 	amount VARCHAR NOT NULL,
 	data BYTEA NOT NULL,
 	log_index INTEGER NOT NULL,
-	block_hash VARCHAR NOT NULL REFERENCES l2_blocks(hash),
+	l1_block_hash VARCHAR REFERENCES l1_blocks(hash),
+	l2_block_hash VARCHAR NOT NULL REFERENCES l2_blocks(hash),
 	tx_hash VARCHAR NOT NULL,
 )
 `

indexer/db/withdrawal.go

@@ -26,15 +26,17 @@ 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"`
+	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"`
+	L1BlockNumber    uint64 `json:"l1BlockNumber"`
+	L1BlockTimestamp string `json:"l1BlockTimestamp"`
+	L2BlockNumber    uint64 `json:"l2BlockNumber"`
+	L2BlockTimestamp string `json:"l2BlockTimestamp"`
+	TxHash           string `json:"transactionHash"`
 }

indexer/indexer.go

@@ -212,6 +212,7 @@ func (b *Indexer) Serve() error {
 	b.router.HandleFunc("/v1/l1/status", b.l1IndexingService.GetIndexerStatus).Methods("GET")
 	b.router.HandleFunc("/v1/l2/status", b.l2IndexingService.GetIndexerStatus).Methods("GET")
 	b.router.HandleFunc("/v1/deposits/0x{address:[a-fA-F0-9]{40}}", b.l1IndexingService.GetDeposits).Methods("GET")
+	b.router.HandleFunc("/v1/withdrawal/0x{hash:[a-fA-F0-9]{64}}", b.l2IndexingService.GetWithdrawalStatus).Methods("GET")
 	b.router.HandleFunc("/v1/withdrawals/0x{address:[a-fA-F0-9]{40}}", b.l2IndexingService.GetWithdrawals).Methods("GET")
 	b.router.HandleFunc("/v1/airdrops/0x{address:[a-fA-F0-9]{40}}", b.airdropService.GetAirdrop)
 	b.router.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {

indexer/services/l1/bridge/bridge.go

@@ -13,10 +13,12 @@ import (
 )
 
 type DepositsMap map[common.Hash][]db.Deposit
+type WithdrawalsMap map[common.Hash][]db.Withdrawal // Finalizations
 
 type Bridge interface {
 	Address() common.Address
 	GetDepositsByBlockRange(uint64, uint64) (DepositsMap, error)
+	GetWithdrawalsByBlockRange(uint64, uint64) (WithdrawalsMap, error)
 	String() string
 }
 

indexer/services/l1/bridge/eth_bridge.go

@@ -50,6 +50,36 @@ func (e *EthBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap, err
 	return depositsByBlockhash, nil
 }
 
+func (s *EthBridge) GetWithdrawalsByBlockRange(start, end uint64) (WithdrawalsMap, error) {
+	withdrawalsByBlockHash := make(WithdrawalsMap)
+
+	iter, err := FilterETHWithdrawalFinalizedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
+		Start: start,
+		End:   &end,
+	})
+
+	if err != nil {
+		logger.Error("Error fetching filter", "err", err)
+	}
+
+	for iter.Next() {
+		withdrawalsByBlockHash[iter.Event.Raw.BlockHash] = append(
+			withdrawalsByBlockHash[iter.Event.Raw.BlockHash], db.Withdrawal{
+				TxHash:      iter.Event.Raw.TxHash,
+				FromAddress: iter.Event.From,
+				ToAddress:   iter.Event.To,
+				Amount:      iter.Event.Amount,
+				Data:        iter.Event.ExtraData,
+				LogIndex:    iter.Event.Raw.Index,
+			})
+	}
+	if err := iter.Error(); err != nil {
+		return nil, err
+	}
+
+	return withdrawalsByBlockHash, nil
+}
+
 func (e *EthBridge) String() string {
 	return e.name
 }

indexer/services/l1/bridge/standard_bridge.go

@@ -52,6 +52,38 @@ func (s *StandardBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap
 	return depositsByBlockhash, nil
 }
 
+func (s *StandardBridge) GetWithdrawalsByBlockRange(start, end uint64) (WithdrawalsMap, error) {
+	withdrawalsByBlockHash := make(WithdrawalsMap)
+
+	iter, err := FilterERC20WithdrawalFinalizedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
+		Start: start,
+		End:   &end,
+	})
+
+	if err != nil {
+		logger.Error("Error fetching filter", "err", err)
+	}
+
+	for iter.Next() {
+		withdrawalsByBlockHash[iter.Event.Raw.BlockHash] = append(
+			withdrawalsByBlockHash[iter.Event.Raw.BlockHash], db.Withdrawal{
+				TxHash:      iter.Event.Raw.TxHash,
+				L1Token:     iter.Event.L1Token,
+				L2Token:     iter.Event.L2Token,
+				FromAddress: iter.Event.From,
+				ToAddress:   iter.Event.To,
+				Amount:      iter.Event.Amount,
+				Data:        iter.Event.ExtraData,
+				LogIndex:    iter.Event.Raw.Index,
+			})
+	}
+	if err := iter.Error(); err != nil {
+		return nil, err
+	}
+
+	return withdrawalsByBlockHash, nil
+}
+
 func (s *StandardBridge) String() string {
 	return s.name
 }