split tests. Bridge -> BridgeTransfers

indexer/database/bridge.go → indexer/database/bridge_transfers.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-
 	"github.com/google/uuid"
 )
 
@@ -30,17 +29,11 @@ type TokenPair struct {
 	L2TokenAddress common.Address `gorm:"serializer:json"`
 }
 
-type Deposit struct {
+type L1BridgeDeposit struct {
 	GUID                 uuid.UUID `gorm:"primaryKey"`
 	InitiatedL1EventGUID uuid.UUID
 
-	// Since we're only currently indexing a single StandardBridge,
-	// the message nonce serves as a unique identifier for this
-	// deposit. Once this generalizes to more than 1 deployed
-	// bridge, we need to include the `CrossDomainMessenger` address
-	// such that the (messenger_addr, nonce) is the unique identifier
-	// for a bridge msg
-	SentMessageNonce U256
+	CrossDomainMessengerNonce U256
 
 	FinalizedL2EventGUID *uuid.UUID
 
@@ -48,24 +41,18 @@ type Deposit struct {
 	TokenPair TokenPair   `gorm:"embedded"`
 }
 
-type DepositWithTransactionHashes struct {
-	Deposit           Deposit     `gorm:"embedded"`
-	L1TransactionHash common.Hash `gorm:"serializer:json"`
+type L1BridgeDepositWithTransactionHashes struct {
+	L1BridgeDeposit L1BridgeDeposit `gorm:"embedded"`
 
+	L1TransactionHash          common.Hash `gorm:"serializer:json"`
 	FinalizedL2TransactionHash common.Hash `gorm:"serializer:json"`
 }
 
-type Withdrawal struct {
+type L2BridgeWithdrawal struct {
 	GUID                 uuid.UUID `gorm:"primaryKey"`
 	InitiatedL2EventGUID uuid.UUID
 
-	// Since we're only currently indexing a single StandardBridge,
-	// the message nonce serves as a unique identifier for this
-	// withdrawal. Once this generalizes to more than 1 deployed
-	// bridge, we need to include the `CrossDomainMessenger` address
-	// such that the (messenger_addr, nonce) is the unique identifier
-	// for a bridge msg
-	SentMessageNonce U256
+	CrossDomainMessengerNonce U256
 
 	WithdrawalHash       common.Hash `gorm:"serializer:json"`
 	ProvenL1EventGUID    *uuid.UUID
@@ -75,108 +62,96 @@ type Withdrawal struct {
 	TokenPair TokenPair   `gorm:"embedded"`
 }
 
-type WithdrawalWithTransactionHashes struct {
-	Withdrawal        Withdrawal  `gorm:"embedded"`
-	L2TransactionHash common.Hash `gorm:"serializer:json"`
+type L2BridgeWithdrawalWithTransactionHashes struct {
+	L2BridgeWithdrawal L2BridgeWithdrawal `gorm:"embedded"`
+	L2TransactionHash  common.Hash        `gorm:"serializer:json"`
 
 	ProvenL1TransactionHash    common.Hash `gorm:"serializer:json"`
 	FinalizedL1TransactionHash common.Hash `gorm:"serializer:json"`
 }
 
-type BridgeView interface {
-	DepositsByAddress(address common.Address) ([]*DepositWithTransactionHashes, error)
-	DepositByMessageNonce(*big.Int) (*Deposit, error)
-	LatestDepositMessageNonce() (*big.Int, error)
+type BridgeTransfersView interface {
+	L1BridgeDepositByCrossDomainMessengerNonce(*big.Int) (*L1BridgeDeposit, error)
+	L1BridgeDepositsByAddress(common.Address) ([]*L1BridgeDepositWithTransactionHashes, error)
 
-	WithdrawalsByAddress(address common.Address) ([]*WithdrawalWithTransactionHashes, error)
-	WithdrawalByMessageNonce(*big.Int) (*Withdrawal, error)
-	WithdrawalByHash(common.Hash) (*Withdrawal, error)
-	LatestWithdrawalMessageNonce() (*big.Int, error)
+	L2BridgeWithdrawalByWithdrawalHash(common.Hash) (*L2BridgeWithdrawal, error)
+	L2BridgeWithdrawalByCrossDomainMessengerNonce(*big.Int) (*L2BridgeWithdrawal, error)
+	L2BridgeWithdrawalsByAddress(common.Address) ([]*L2BridgeWithdrawalWithTransactionHashes, error)
 }
 
-type BridgeDB interface {
-	BridgeView
+type BridgeTransfersDB interface {
+	BridgeTransfersView
 
-	StoreDeposits([]*Deposit) error
-	MarkFinalizedDepositEvent(uuid.UUID, uuid.UUID) error
+	StoreL1BridgeDeposits([]*L1BridgeDeposit) error
+	MarkFinalizedL1BridgeDepositEvent(uuid.UUID, uuid.UUID) error
 
-	StoreWithdrawals([]*Withdrawal) error
-	MarkProvenWithdrawalEvent(uuid.UUID, uuid.UUID) error
-	MarkFinalizedWithdrawalEvent(uuid.UUID, uuid.UUID) error
+	StoreL2BridgeWithdrawals([]*L2BridgeWithdrawal) error
+	MarkProvenL2BridgeWithdrawalEvent(uuid.UUID, uuid.UUID) error
+	MarkFinalizedL2BridgeWithdrawalEvent(uuid.UUID, uuid.UUID) error
 }
 
 /**
  * Implementation
  */
 
-type bridgeDB struct {
+type bridgeTransfersDB struct {
 	gorm *gorm.DB
 }
 
-func newBridgeDB(db *gorm.DB) BridgeDB {
-	return &bridgeDB{gorm: db}
+func newBridgeTransfersDB(db *gorm.DB) BridgeTransfersDB {
+	return &bridgeTransfersDB{gorm: db}
 }
 
-// Deposits
+/**
+ * Tokens Bridged (Deposited) from L1
+ */
 
-func (db *bridgeDB) StoreDeposits(deposits []*Deposit) error {
+func (db *bridgeTransfersDB) StoreL1BridgeDeposits(deposits []*L1BridgeDeposit) error {
 	result := db.gorm.Create(&deposits)
 	return result.Error
 }
 
-func (db *bridgeDB) DepositsByAddress(address common.Address) ([]*DepositWithTransactionHashes, error) {
-	depositsQuery := db.gorm.Table("deposits").Select("deposits.*, l1_contract_events.transaction_hash AS l1_transaction_hash, l2_contract_events.transaction_hash AS finalized_l2_transaction_hash")
-
-	initiatedJoinQuery := depositsQuery.Joins("LEFT JOIN l1_contract_events ON deposits.initiated_l1_event_guid = l1_contract_events.guid")
-	finalizedJoinQuery := initiatedJoinQuery.Joins("LEFT JOIN l2_contract_events ON deposits.finalized_l2_event_guid = l2_contract_events.guid")
-
-	// add in cursoring options
-	filteredQuery := finalizedJoinQuery.Where(&Transaction{FromAddress: address}).Order("deposits.timestamp DESC").Limit(100)
-
-	deposits := make([]*DepositWithTransactionHashes, 100)
-	result := filteredQuery.Scan(&deposits)
+// L1BridgeDepositByMessageNonce retrieves tokens deposited, specified by the associated `L1CrossDomainMessenger` nonce.
+// All tokens bridged via the StandardBridge flows through the L1CrossDomainMessenger
+func (db *bridgeTransfersDB) L1BridgeDepositByCrossDomainMessengerNonce(nonce *big.Int) (*L1BridgeDeposit, error) {
+	var deposit L1BridgeDeposit
+	result := db.gorm.Where(&L1BridgeDeposit{CrossDomainMessengerNonce: U256{Int: nonce}}).Take(&deposit)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
-	return deposits, nil
+	return &deposit, nil
 }
 
-func (db *bridgeDB) DepositByMessageNonce(nonce *big.Int) (*Deposit, error) {
-	var deposit Deposit
-	result := db.gorm.Where(&Deposit{SentMessageNonce: U256{Int: nonce}}).Take(&deposit)
-	if result.Error != nil {
-		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
-			return nil, nil
-		}
+// L1BridgeDepositsByAddress retrieves a list of deposits intiated by the specified address, coupled with the L1/L2 transaction
+// hashes that complete the bridge transaction.
+func (db *bridgeTransfersDB) L1BridgeDepositsByAddress(address common.Address) ([]*L1BridgeDepositWithTransactionHashes, error) {
+	depositsQuery := db.gorm.Table("l1_bridge_deposits").Select("l1_bridge_deposits.*, l1_contract_events.transaction_hash AS l1_transaction_hash, l2_contract_events.transaction_hash AS finalized_l2_transaction_hash")
 
-		return nil, result.Error
-	}
+	initiatedJoinQuery := depositsQuery.Joins("LEFT JOIN l1_contract_events ON l1_bridge_deposits.initiated_l1_event_guid = l1_contract_events.guid")
+	finalizedJoinQuery := initiatedJoinQuery.Joins("LEFT JOIN l2_contract_events ON l1_bridge_deposits.finalized_l2_event_guid = l2_contract_events.guid")
 
-	return &deposit, nil
-}
+	// add in cursoring options
+	filteredQuery := finalizedJoinQuery.Where(&Transaction{FromAddress: address}).Order("l1_bridge_deposits.timestamp DESC").Limit(100)
 
-func (db *bridgeDB) LatestDepositMessageNonce() (*big.Int, error) {
-	var deposit Deposit
-	result := db.gorm.Order("sent_message_nonce DESC").Take(&deposit)
+	deposits := []*L1BridgeDepositWithTransactionHashes{}
+	result := filteredQuery.Scan(&deposits)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
-	return deposit.SentMessageNonce.Int, nil
+	return deposits, nil
 }
 
-func (db *bridgeDB) MarkFinalizedDepositEvent(guid, finalizationEventGUID uuid.UUID) error {
-	var deposit Deposit
-	result := db.gorm.Where(&Deposit{GUID: guid}).Take(&deposit)
+func (db *bridgeTransfersDB) MarkFinalizedL1BridgeDepositEvent(guid, finalizationEventGUID uuid.UUID) error {
+	var deposit L1BridgeDeposit
+	result := db.gorm.Where(&L1BridgeDeposit{GUID: guid}).Take(&deposit)
 	if result.Error != nil {
 		return result.Error
 	}
@@ -186,102 +161,91 @@ func (db *bridgeDB) MarkFinalizedDepositEvent(guid, finalizationEventGUID uuid.U
 	return result.Error
 }
 
-// Withdrawals
+/**
+ * Tokens Bridged (Withdrawn) from L2
+ */
 
-func (db *bridgeDB) StoreWithdrawals(withdrawals []*Withdrawal) error {
+func (db *bridgeTransfersDB) StoreL2BridgeWithdrawals(withdrawals []*L2BridgeWithdrawal) error {
 	result := db.gorm.Create(&withdrawals)
 	return result.Error
 }
 
-func (db *bridgeDB) MarkProvenWithdrawalEvent(guid, provenL1EventGuid uuid.UUID) error {
-	var withdrawal Withdrawal
-	result := db.gorm.Where(&Withdrawal{GUID: guid}).Take(&withdrawal)
+func (db *bridgeTransfersDB) L2BridgeWithdrawalByWithdrawalHash(withdrawalHash common.Hash) (*L2BridgeWithdrawal, error) {
+	var withdrawal L2BridgeWithdrawal
+	result := db.gorm.Where(&L2BridgeWithdrawal{WithdrawalHash: withdrawalHash}).Take(&withdrawal)
 	if result.Error != nil {
-		return result.Error
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
 	}
 
-	withdrawal.ProvenL1EventGUID = &provenL1EventGuid
-	result = db.gorm.Save(&withdrawal)
-	return result.Error
+	return &withdrawal, nil
 }
 
-func (db *bridgeDB) MarkFinalizedWithdrawalEvent(guid, finalizedL1EventGuid uuid.UUID) error {
-	var withdrawal Withdrawal
-	result := db.gorm.Where(&Withdrawal{GUID: guid}).Take(&withdrawal)
+// L2BridgeWithdrawalByCrossDomainMessengerNonce retrieves tokens withdrawn, specified by the associated `L2CrossDomainMessenger` nonce.
+// All tokens bridged via the StandardBridge flows through the L2CrossDomainMessenger
+func (db *bridgeTransfersDB) L2BridgeWithdrawalByCrossDomainMessengerNonce(nonce *big.Int) (*L2BridgeWithdrawal, error) {
+	var withdrawal L2BridgeWithdrawal
+	result := db.gorm.Where(&L2BridgeWithdrawal{CrossDomainMessengerNonce: U256{Int: nonce}}).Take(&withdrawal)
 	if result.Error != nil {
-		return result.Error
-	}
-
-	if withdrawal.ProvenL1EventGUID == nil {
-		return fmt.Errorf("withdrawal %s marked finalized prior to being proven", guid)
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
 	}
 
-	withdrawal.FinalizedL1EventGUID = &finalizedL1EventGuid
-	result = db.gorm.Save(&withdrawal)
-	return result.Error
+	return &withdrawal, nil
 }
 
-func (db *bridgeDB) WithdrawalsByAddress(address common.Address) ([]*WithdrawalWithTransactionHashes, error) {
-	withdrawalsQuery := db.gorm.Table("withdrawals").Select("withdrawals.*, l2_contract_events.transaction_hash AS l2_transaction_hash, proven_l1_contract_events.transaction_hash AS proven_l1_transaction_hash, finalized_l1_contract_events.transaction_hash AS finalized_l1_transaction_hash")
+// L2BridgeDepositsByAddress retrieves a list of deposits intiated by the specified address, coupled with the L1/L2 transaction hashes
+// that complete the bridge transaction. The hashes that correspond to with the Bedrock multistep withdrawal process are also surfaced
+func (db *bridgeTransfersDB) L2BridgeWithdrawalsByAddress(address common.Address) ([]*L2BridgeWithdrawalWithTransactionHashes, error) {
+	withdrawalsQuery := db.gorm.Table("l2_bridge_withdrawals").Select("l2_bridge_withdrawals.*, l2_contract_events.transaction_hash AS l2_transaction_hash, proven_l1_contract_events.transaction_hash AS proven_l1_transaction_hash, finalized_l1_contract_events.transaction_hash AS finalized_l1_transaction_hash")
 
-	eventsJoinQuery := withdrawalsQuery.Joins("LEFT JOIN l2_contract_events ON withdrawals.initiated_l2_event_guid = l2_contract_events.guid")
-	provenJoinQuery := eventsJoinQuery.Joins("LEFT JOIN l1_contract_events AS proven_l1_contract_events ON withdrawals.proven_l1_event_guid = proven_l1_contract_events.guid")
-	finalizedJoinQuery := provenJoinQuery.Joins("LEFT JOIN l1_contract_events AS finalized_l1_contract_events ON withdrawals.finalized_l1_event_guid = finalized_l1_contract_events.guid")
+	eventsJoinQuery := withdrawalsQuery.Joins("LEFT JOIN l2_contract_events ON l2_bridge_withdrawals.initiated_l2_event_guid = l2_contract_events.guid")
+	provenJoinQuery := eventsJoinQuery.Joins("LEFT JOIN l1_contract_events AS proven_l1_contract_events ON l2_bridge_withdrawals.proven_l1_event_guid = proven_l1_contract_events.guid")
+	finalizedJoinQuery := provenJoinQuery.Joins("LEFT JOIN l1_contract_events AS finalized_l1_contract_events ON l2_bridge_withdrawals.finalized_l1_event_guid = finalized_l1_contract_events.guid")
 
 	// add in cursoring options
-	filteredQuery := finalizedJoinQuery.Where(&Transaction{FromAddress: address}).Order("withdrawals.timestamp DESC").Limit(100)
+	filteredQuery := finalizedJoinQuery.Where(&Transaction{FromAddress: address}).Order("l2_bridge_withdrawals.timestamp DESC").Limit(100)
 
-	withdrawals := make([]*WithdrawalWithTransactionHashes, 100)
+	withdrawals := []*L2BridgeWithdrawalWithTransactionHashes{}
 	result := filteredQuery.Scan(&withdrawals)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
 	return withdrawals, nil
 }
 
-func (db *bridgeDB) WithdrawalByMessageNonce(nonce *big.Int) (*Withdrawal, error) {
-	var withdrawal Withdrawal
-	result := db.gorm.Where(&Withdrawal{SentMessageNonce: U256{Int: nonce}}).Take(&withdrawal)
+func (db *bridgeTransfersDB) MarkProvenL2BridgeWithdrawalEvent(guid, provenL1EventGuid uuid.UUID) error {
+	var withdrawal L2BridgeWithdrawal
+	result := db.gorm.Where(&L2BridgeWithdrawal{GUID: guid}).Take(&withdrawal)
 	if result.Error != nil {
-		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
-			return nil, nil
-		}
-
-		return nil, result.Error
+		return result.Error
 	}
 
-	return &withdrawal, nil
+	withdrawal.ProvenL1EventGUID = &provenL1EventGuid
+	result = db.gorm.Save(&withdrawal)
+	return result.Error
 }
 
-func (db *bridgeDB) WithdrawalByHash(hash common.Hash) (*Withdrawal, error) {
-	var withdrawal Withdrawal
-	result := db.gorm.Where(&Withdrawal{WithdrawalHash: hash}).Take(&withdrawal)
+func (db *bridgeTransfersDB) MarkFinalizedL2BridgeWithdrawalEvent(guid, finalizedL1EventGuid uuid.UUID) error {
+	var withdrawal L2BridgeWithdrawal
+	result := db.gorm.Where(&L2BridgeWithdrawal{GUID: guid}).Take(&withdrawal)
 	if result.Error != nil {
-		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
-			return nil, nil
-		}
-
-		return nil, result.Error
+		return result.Error
 	}
 
-	return &withdrawal, nil
-}
-
-func (db *bridgeDB) LatestWithdrawalMessageNonce() (*big.Int, error) {
-	var withdrawal Withdrawal
-	result := db.gorm.Order("sent_message_nonce DESC").Take(&withdrawal)
-	if result.Error != nil {
-		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
-			return nil, nil
-		}
-
-		return nil, result.Error
+	if withdrawal.ProvenL1EventGUID == nil {
+		return fmt.Errorf("withdrawal %s marked finalized prior to being proven", guid)
 	}
 
-	return withdrawal.SentMessageNonce.Int, nil
+	withdrawal.FinalizedL1EventGUID = &finalizedL1EventGuid
+	result = db.gorm.Save(&withdrawal)
+	return result.Error
 }

indexer/database/db.go

@@ -10,9 +10,9 @@ import (
 type DB struct {
 	gorm *gorm.DB
 
-	Blocks         BlocksDB
-	ContractEvents ContractEventsDB
-	Bridge         BridgeDB
+	Blocks          BlocksDB
+	ContractEvents  ContractEventsDB
+	BridgeTransfers BridgeTransfersDB
 }
 
 func NewDB(dsn string) (*DB, error) {
@@ -31,10 +31,10 @@ func NewDB(dsn string) (*DB, error) {
 	}
 
 	db := &DB{
-		gorm:           gorm,
-		Blocks:         newBlocksDB(gorm),
-		ContractEvents: newContractEventsDB(gorm),
-		Bridge:         newBridgeDB(gorm),
+		gorm:            gorm,
+		Blocks:          newBlocksDB(gorm),
+		ContractEvents:  newContractEventsDB(gorm),
+		BridgeTransfers: newBridgeTransfersDB(gorm),
 	}
 
 	return db, nil
@@ -59,9 +59,9 @@ func (db *DB) Close() error {
 
 func dbFromGormTx(tx *gorm.DB) *DB {
 	return &DB{
-		gorm:           tx,
-		Blocks:         newBlocksDB(tx),
-		ContractEvents: newContractEventsDB(tx),
-		Bridge:         newBridgeDB(tx),
+		gorm:            tx,
+		Blocks:          newBlocksDB(tx),
+		ContractEvents:  newContractEventsDB(tx),
+		BridgeTransfers: newBridgeTransfersDB(tx),
 	}
 }

indexer/e2e_test/bridge_e2e_test.go

-package e2e_tests
-
-import (
-	"context"
-	"math/big"
-	"testing"
-	"time"
-
-	"github.com/ethereum-optimism/optimism/indexer/processor"
-	"github.com/ethereum-optimism/optimism/op-service/client/utils"
-
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
-	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
-	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
-
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/params"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestE2EBridge(t *testing.T) {
-	testSuite := createE2ETestSuite(t)
-
-	l1Client := testSuite.OpSys.Clients["l1"]
-	l2Client := testSuite.OpSys.Clients["sequencer"]
-
-	l1StandardBridge, err := bindings.NewL1StandardBridge(testSuite.OpCfg.L1Deployments.L1StandardBridgeProxy, l1Client)
-	require.NoError(t, err)
-
-	l2StandardBridge, err := bindings.NewL2StandardBridge(predeploys.L2StandardBridgeAddr, l2Client)
-	require.NoError(t, err)
-
-	// pre-emptively conduct a deposit & withdrawal to speed up the test
-	setupCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
-
-	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
-	require.NoError(t, err)
-	l2Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L2ChainIDBig())
-	require.NoError(t, err)
-
-	l1Opts.Value = big.NewInt(params.Ether)
-	l2Opts.Value = big.NewInt(params.Ether)
-
-	depositTx, err := l1StandardBridge.DepositETH(l1Opts, 200_000, []byte{byte(1)})
-	require.NoError(t, err)
-
-	withdrawTx, err := l2StandardBridge.Withdraw(l2Opts, processor.EthAddress, big.NewInt(params.Ether), 200_000, []byte{byte(1)})
-	require.NoError(t, err)
-
-	depositReceipt, err := utils.WaitReceiptOK(setupCtx, l1Client, depositTx.Hash())
-	require.NoError(t, err)
-
-	withdrawalReceipt, err := utils.WaitReceiptOK(setupCtx, l2Client, withdrawTx.Hash())
-	require.NoError(t, err)
-
-	t.Run("indexes ETH deposits", func(t *testing.T) {
-		testCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
-		defer cancel()
-
-		// Pause the L2Processor so that we can test for finalization separately. A pause is
-		// required since deposit inclusion is apart of the L2 block derivation process
-		testSuite.Indexer.L2Processor.PauseForTest()
-
-		// (1) Test Deposit Initiation
-
-		// wait for processor catchup
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
-			return l1Header != nil && l1Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
-		}))
-
-		aliceDeposits, err := testSuite.DB.Bridge.DepositsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Len(t, aliceDeposits, 1)
-		require.Equal(t, depositTx.Hash(), aliceDeposits[0].L1TransactionHash)
-		require.Empty(t, aliceDeposits[0].FinalizedL2TransactionHash)
-
-		deposit := aliceDeposits[0].Deposit
-		require.Nil(t, deposit.FinalizedL2EventGUID)
-		require.Equal(t, processor.EthAddress, deposit.TokenPair.L1TokenAddress)
-		require.Equal(t, processor.EthAddress, deposit.TokenPair.L2TokenAddress)
-		require.Equal(t, big.NewInt(params.Ether), deposit.Tx.Amount.Int)
-		require.Equal(t, aliceAddr, deposit.Tx.FromAddress)
-		require.Equal(t, aliceAddr, deposit.Tx.ToAddress)
-		require.Equal(t, byte(1), deposit.Tx.Data[0])
-
-		// (2) Test Deposit Finalization
-		testSuite.Indexer.L2Processor.ResumeForTest()
-
-		// finalization hash can be deterministically derived from TransactionDeposited log
-		var depositTxHash common.Hash
-		for _, log := range depositReceipt.Logs {
-			if log.Topics[0] == derive.DepositEventABIHash {
-				deposit, err := derive.UnmarshalDepositLogEvent(log)
-				require.NoError(t, err)
-				depositTxHash = types.NewTx(deposit).Hash()
-				break
-			}
-		}
-
-		// wait for the l2 processor to catch this deposit in the derivation process
-		_, err = utils.WaitReceiptOK(testCtx, l2Client, depositTxHash)
-		require.NoError(t, err)
-		l2Height, err := l2Client.BlockNumber(testCtx)
-		require.NoError(t, err)
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
-			return l2Header != nil && l2Header.Number.Uint64() >= l2Height, nil
-		}))
-
-		aliceDeposits, err = testSuite.DB.Bridge.DepositsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Equal(t, depositTxHash, aliceDeposits[0].FinalizedL2TransactionHash)
-		require.NotNil(t, aliceDeposits[0].Deposit.FinalizedL2EventGUID)
-	})
-
-	t.Run("indexes ETH withdrawals", func(t *testing.T) {
-		testCtx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
-		defer cancel()
-
-		// (1) Test Withdrawal Initiation
-
-		// wait for processor catchup
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
-			return l2Header != nil && l2Header.Number.Uint64() >= withdrawalReceipt.BlockNumber.Uint64(), nil
-		}))
-
-		aliceWithdrawals, err := testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Len(t, aliceWithdrawals, 1)
-		require.Equal(t, withdrawTx.Hash(), aliceWithdrawals[0].L2TransactionHash)
-		require.Empty(t, aliceWithdrawals[0].ProvenL1TransactionHash)
-		require.Empty(t, aliceWithdrawals[0].FinalizedL1TransactionHash)
-
-		withdrawal := aliceWithdrawals[0].Withdrawal
-		require.Nil(t, withdrawal.ProvenL1EventGUID)
-		require.Nil(t, withdrawal.FinalizedL1EventGUID)
-		require.Equal(t, processor.EthAddress, withdrawal.TokenPair.L1TokenAddress)
-		require.Equal(t, processor.EthAddress, withdrawal.TokenPair.L2TokenAddress)
-		require.Equal(t, big.NewInt(params.Ether), withdrawal.Tx.Amount.Int)
-		require.Equal(t, aliceAddr, withdrawal.Tx.FromAddress)
-		require.Equal(t, aliceAddr, withdrawal.Tx.ToAddress)
-		require.Equal(t, byte(1), withdrawal.Tx.Data[0])
-
-		// (2) Test Withdrawal Proven
-
-		// prove & wait for processor catchup
-		withdrawParams, proveReceipt := op_e2e.ProveWithdrawal(t, *testSuite.OpCfg, l1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawalReceipt)
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
-			return l1Header != nil && l1Header.Number.Uint64() >= proveReceipt.BlockNumber.Uint64(), nil
-		}))
-
-		aliceWithdrawals, err = testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Empty(t, aliceWithdrawals[0].FinalizedL1TransactionHash)
-		require.Equal(t, proveReceipt.TxHash, aliceWithdrawals[0].ProvenL1TransactionHash)
-
-		// (3) Test Withdrawal Finalization
-
-		// finalize & wait for processor catchup
-		finalizeReceipt := op_e2e.FinalizeWithdrawal(t, *testSuite.OpCfg, l1Client, testSuite.OpCfg.Secrets.Alice, proveReceipt, withdrawParams)
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
-			return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
-		}))
-
-		aliceWithdrawals, err = testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Equal(t, finalizeReceipt.TxHash, aliceWithdrawals[0].FinalizedL1TransactionHash)
-	})
-}

indexer/e2e_test/blocks_e2e_test.go → indexer/e2e_tests/blocks_e2e_test.go

@@ -23,9 +23,7 @@ import (
 func TestE2EBlockHeaders(t *testing.T) {
 	testSuite := createE2ETestSuite(t)
 
-	l1Client := testSuite.OpSys.Clients["l1"]
-	l2Client := testSuite.OpSys.Clients["sequencer"]
-	l2OutputOracle, err := bindings.NewL2OutputOracleCaller(testSuite.OpCfg.L1Deployments.L2OutputOracleProxy, l1Client)
+	l2OutputOracle, err := bindings.NewL2OutputOracle(testSuite.OpCfg.L1Deployments.L2OutputOracleProxy, testSuite.L1Client)
 	require.NoError(t, err)
 
 	// a minute for total setup to finish
@@ -39,7 +37,7 @@ func TestE2EBlockHeaders(t *testing.T) {
 	}))
 
 	// ensure the processors are caught up to this state
-	l1Height, err := l1Client.BlockNumber(setupCtx)
+	l1Height, err := testSuite.L1Client.BlockNumber(setupCtx)
 	require.NoError(t, err)
 	require.NoError(t, utils.WaitFor(setupCtx, time.Second, func() (bool, error) {
 		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
@@ -60,7 +58,7 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.NoError(t, err)
 			require.NotNil(t, indexedHeader)
 
-			header, err := l2Client.HeaderByNumber(context.Background(), height)
+			header, err := testSuite.L2Client.HeaderByNumber(context.Background(), height)
 			require.NoError(t, err)
 			require.NotNil(t, indexedHeader)
 
@@ -93,7 +91,7 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.NotEmpty(t, output.L1ContractEventGUID)
 
 			// we may as well check the integrity of the output root
-			l2Block, err := l2Client.BlockByNumber(context.Background(), blockNumber)
+			l2Block, err := testSuite.L2Client.BlockByNumber(context.Background(), blockNumber)
 			require.NoError(t, err)
 			messagePasserStorageHash, err := l2EthClient.StorageHash(predeploys.L2ToL1MessagePasserAddr, blockNumber)
 			require.NoError(t, err)
@@ -111,12 +109,10 @@ func TestE2EBlockHeaders(t *testing.T) {
 		testCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
 
-		devContracts := make([]common.Address, 0)
-		testSuite.OpCfg.L1Deployments.ForEach(func(name string, address common.Address) {
-			devContracts = append(devContracts, address)
-		})
-		logFilter := ethereum.FilterQuery{FromBlock: big.NewInt(0), ToBlock: big.NewInt(int64(l1Height)), Addresses: devContracts}
-		logs, err := l1Client.FilterLogs(testCtx, logFilter) // []types.Log
+		l1Contracts := []common.Address{}
+		testSuite.OpCfg.L1Deployments.ForEach(func(name string, addr common.Address) { l1Contracts = append(l1Contracts, addr) })
+		logFilter := ethereum.FilterQuery{FromBlock: big.NewInt(0), ToBlock: big.NewInt(int64(l1Height)), Addresses: l1Contracts}
+		logs, err := testSuite.L1Client.FilterLogs(testCtx, logFilter) // []types.Log
 		require.NoError(t, err)
 
 		for _, log := range logs {
@@ -128,7 +124,7 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.Equal(t, log.Index, uint(contractEvent.LogIndex))
 
 			// ensure the block is also indexed
-			block, err := l1Client.BlockByNumber(testCtx, big.NewInt(int64(log.BlockNumber)))
+			block, err := testSuite.L1Client.BlockByNumber(testCtx, big.NewInt(int64(log.BlockNumber)))
 			require.NoError(t, err)
 
 			require.Equal(t, block.Time(), contractEvent.Timestamp)

indexer/e2e_tests/bridge_transfers_e2e_test.go

+package e2e_tests
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	e2etest_utils "github.com/ethereum-optimism/optimism/indexer/e2e_tests/utils"
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-node/withdrawals"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum-optimism/optimism/op-service/client/utils"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestE2EBridgeTransfersStandardBridgeETHDeposit(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+	testCtx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	l1StandardBridge, err := bindings.NewL1StandardBridge(testSuite.OpCfg.L1Deployments.L1StandardBridgeProxy, testSuite.L1Client)
+	require.NoError(t, err)
+
+	// 1 ETH transfer
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
+	require.NoError(t, err)
+	l1Opts.Value = big.NewInt(params.Ether)
+
+	// Pause the L2Processor so that we can test for finalization separately. A pause is
+	// required since deposit inclusion is apart of the L2 block derivation process
+	testSuite.Indexer.L2Processor.PauseForTest()
+
+	// (1) Test Deposit Initiation
+	depositTx, err := l1StandardBridge.DepositETH(l1Opts, 200_000, []byte{byte(1)})
+	require.NoError(t, err)
+	depositReceipt, err := utils.WaitReceiptOK(testCtx, testSuite.L1Client, depositTx.Hash())
+	require.NoError(t, err)
+
+	depositInfo, err := e2etest_utils.ParseDepositInfo(depositReceipt)
+	require.NoError(t, err)
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	aliceDeposits, err := testSuite.DB.BridgeTransfers.L1BridgeDepositsByAddress(aliceAddr)
+	require.NoError(t, err)
+	require.Len(t, aliceDeposits, 1)
+	require.Equal(t, depositTx.Hash(), aliceDeposits[0].L1TransactionHash)
+	require.Empty(t, aliceDeposits[0].FinalizedL2TransactionHash)
+
+	deposit := aliceDeposits[0].L1BridgeDeposit
+	require.Equal(t, predeploys.LegacyERC20ETHAddr, deposit.TokenPair.L1TokenAddress)
+	require.Equal(t, predeploys.LegacyERC20ETHAddr, deposit.TokenPair.L2TokenAddress)
+	require.Equal(t, big.NewInt(params.Ether), deposit.Tx.Amount.Int)
+	require.Equal(t, aliceAddr, deposit.Tx.FromAddress)
+	require.Equal(t, aliceAddr, deposit.Tx.ToAddress)
+	require.Equal(t, byte(1), deposit.Tx.Data[0])
+
+	// (2) Test Deposit Finalization
+	require.Nil(t, deposit.FinalizedL2EventGUID)
+	testSuite.Indexer.L2Processor.ResumeForTest()
+
+	// wait for the l2 processor to catch this deposit in the derivation process
+	depositReceipt, err = utils.WaitReceiptOK(testCtx, testSuite.L2Client, types.NewTx(depositInfo.DepositTx).Hash())
+	require.NoError(t, err)
+	require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
+		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		return l2Header != nil && l2Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	aliceDeposits, err = testSuite.DB.BridgeTransfers.L1BridgeDepositsByAddress(aliceAddr)
+	require.NoError(t, err)
+	require.NotNil(t, aliceDeposits[0].L1BridgeDeposit.FinalizedL2EventGUID)
+	require.Equal(t, types.NewTx(depositInfo.DepositTx).Hash(), aliceDeposits[0].FinalizedL2TransactionHash)
+}
+
+func TestE2EBridgeTransfersStandardBridgeETHWithdrawal(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+	testCtx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+
+	optimismPortal, err := bindings.NewOptimismPortal(testSuite.OpCfg.L1Deployments.OptimismPortalProxy, testSuite.L1Client)
+	require.NoError(t, err)
+	l2StandardBridge, err := bindings.NewL2StandardBridge(predeploys.L2StandardBridgeAddr, testSuite.L2Client)
+	require.NoError(t, err)
+
+	// 1 ETH transfer
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+	l2Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L2ChainIDBig())
+	require.NoError(t, err)
+	l2Opts.Value = big.NewInt(params.Ether)
+
+	// Ensure L1 has enough funds for the withdrawal by depositing an equal amount into the OptimismPortal
+	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
+	require.NoError(t, err)
+	l1Opts.Value = l2Opts.Value
+	depositTx, err := optimismPortal.Receive(l1Opts)
+	require.NoError(t, err)
+	_, err = utils.WaitReceiptOK(testCtx, testSuite.L1Client, depositTx.Hash())
+	require.NoError(t, err)
+
+	// (1) Test Withdrawal Initiation
+	withdrawTx, err := l2StandardBridge.Withdraw(l2Opts, predeploys.LegacyERC20ETHAddr, l2Opts.Value, 200_000, []byte{byte(1)})
+	require.NoError(t, err)
+	withdrawReceipt, err := utils.WaitReceiptOK(testCtx, testSuite.L2Client, withdrawTx.Hash())
+	require.NoError(t, err)
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
+		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		return l2Header != nil && l2Header.Number.Uint64() >= withdrawReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	aliceWithdrawals, err := testSuite.DB.BridgeTransfers.L2BridgeWithdrawalsByAddress(aliceAddr)
+	require.NoError(t, err)
+	require.Len(t, aliceWithdrawals, 1)
+	require.Equal(t, withdrawTx.Hash(), aliceWithdrawals[0].L2TransactionHash)
+
+	msgPassed, err := withdrawals.ParseMessagePassed(withdrawReceipt)
+	require.NoError(t, err)
+	withdrawalHash, err := withdrawals.WithdrawalHash(msgPassed)
+	require.NoError(t, err)
+
+	withdrawal := aliceWithdrawals[0].L2BridgeWithdrawal
+	require.Equal(t, withdrawalHash, withdrawal.WithdrawalHash)
+	require.Equal(t, predeploys.LegacyERC20ETHAddr, withdrawal.TokenPair.L1TokenAddress)
+	require.Equal(t, predeploys.LegacyERC20ETHAddr, withdrawal.TokenPair.L2TokenAddress)
+	require.Equal(t, big.NewInt(params.Ether), withdrawal.Tx.Amount.Int)
+	require.Equal(t, aliceAddr, withdrawal.Tx.FromAddress)
+	require.Equal(t, aliceAddr, withdrawal.Tx.ToAddress)
+	require.Equal(t, byte(1), withdrawal.Tx.Data[0])
+
+	// (2) Test Withdrawal Proven/Finalized. Test the sql join queries to populate the right transaction
+	require.Nil(t, withdrawal.ProvenL1EventGUID)
+	require.Nil(t, withdrawal.FinalizedL1EventGUID)
+	require.Empty(t, aliceWithdrawals[0].ProvenL1TransactionHash)
+	require.Empty(t, aliceWithdrawals[0].FinalizedL1TransactionHash)
+
+	// wait for processor catchup
+	proveReceipt, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
+	require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	aliceWithdrawals, err = testSuite.DB.BridgeTransfers.L2BridgeWithdrawalsByAddress(aliceAddr)
+	require.NoError(t, err)
+	require.NotNil(t, aliceWithdrawals[0].L2BridgeWithdrawal.ProvenL1EventGUID)
+	require.NotNil(t, aliceWithdrawals[0].L2BridgeWithdrawal.FinalizedL1EventGUID)
+	require.Equal(t, proveReceipt.TxHash, aliceWithdrawals[0].ProvenL1TransactionHash)
+	require.Equal(t, finalizeReceipt.TxHash, aliceWithdrawals[0].FinalizedL1TransactionHash)
+}

indexer/e2e_test/setup.go → indexer/e2e_tests/setup.go

@@ -17,6 +17,7 @@ import (
 
 	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 
 	_ "github.com/jackc/pgx/v5/stdlib"
@@ -33,6 +34,10 @@ type E2ETestSuite struct {
 	// Rollup
 	OpCfg *op_e2e.SystemConfig
 	OpSys *op_e2e.System
+
+	// Clients
+	L1Client *ethclient.Client
+	L2Client *ethclient.Client
 }
 
 func createE2ETestSuite(t *testing.T) E2ETestSuite {
@@ -48,16 +53,9 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 	opSys, err := opCfg.Start()
 	require.NoError(t, err)
 
-	l1Contracts := processor.L1Contracts{
-		OptimismPortal:         opCfg.L1Deployments.OptimismPortalProxy,
-		L2OutputOracle:         opCfg.L1Deployments.L2OutputOracleProxy,
-		L1CrossDomainMessenger: opCfg.L1Deployments.L1CrossDomainMessengerProxy,
-		L1StandardBridge:       opCfg.L1Deployments.L1StandardBridgeProxy,
-		L1ERC721Bridge:         opCfg.L1Deployments.L1ERC721BridgeProxy,
-	}
-
 	// Indexer Configuration and Start
 	indexerCfg := config.Config{
+		Logger: logger,
 		DB: config.DBConfig{
 			Host: "127.0.0.1",
 			Port: 5432,
@@ -68,9 +66,14 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 			L1RPC: opSys.Nodes["l1"].HTTPEndpoint(),
 			L2RPC: opSys.Nodes["sequencer"].HTTPEndpoint(),
 		},
-		Logger: logger,
 		Chain: config.ChainConfig{
-			L1Contracts: l1Contracts,
+			L1Contracts: processor.L1Contracts{
+				OptimismPortal:         opCfg.L1Deployments.OptimismPortalProxy,
+				L2OutputOracle:         opCfg.L1Deployments.L2OutputOracleProxy,
+				L1CrossDomainMessenger: opCfg.L1Deployments.L1CrossDomainMessengerProxy,
+				L1StandardBridge:       opCfg.L1Deployments.L1StandardBridgeProxy,
+				L1ERC721Bridge:         opCfg.L1Deployments.L1ERC721BridgeProxy,
+			},
 		},
 	}
 
@@ -99,11 +102,13 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 	})
 
 	return E2ETestSuite{
-		t:       t,
-		DB:      db,
-		Indexer: indexer,
-		OpCfg:   &opCfg,
-		OpSys:   opSys,
+		t:        t,
+		DB:       db,
+		Indexer:  indexer,
+		OpCfg:    &opCfg,
+		OpSys:    opSys,
+		L1Client: opSys.Clients["l1"],
+		L2Client: opSys.Clients["sequencer"],
 	}
 }
 

indexer/e2e_tests/utils/deposits.go

+package utils
+
+import (
+	"errors"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type DepositInfo struct {
+	*bindings.OptimismPortalTransactionDeposited
+	DepositTx *types.DepositTx
+}
+
+func ParseDepositInfo(depositReceipt *types.Receipt) (*DepositInfo, error) {
+	optimismPortal, err := bindings.NewOptimismPortal(common.Address{}, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, log := range depositReceipt.Logs {
+		if log.Topics[0] == derive.DepositEventABIHash {
+			portalTxDeposited, err := optimismPortal.ParseTransactionDeposited(*log)
+			if err != nil {
+				return nil, err
+			}
+			depositTx, err := derive.UnmarshalDepositLogEvent(log)
+			if err != nil {
+				return nil, err
+			}
+
+			return &DepositInfo{portalTxDeposited, depositTx}, nil
+		}
+	}
+
+	return nil, errors.New("cannot find deposit event in receipt")
+}

indexer/migrations/20230523_create_schema.sql

@@ -67,12 +67,12 @@ CREATE TABLE IF NOT EXISTS output_proposals (
  * BRIDGING DATA
  */
 
-CREATE TABLE IF NOT EXISTS deposits (
+CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
 	guid                 VARCHAR PRIMARY KEY NOT NULL,
 
     -- Event causing the deposit
-    initiated_l1_event_guid VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
-    sent_message_nonce      UINT256 UNIQUE,
+    initiated_l1_event_guid      VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
+    cross_domain_messenger_nonce UINT256 UNIQUE,
 
     -- Finalization marker for the deposit
     finalized_l2_event_guid VARCHAR REFERENCES l2_contract_events(guid),
@@ -88,12 +88,12 @@ CREATE TABLE IF NOT EXISTS deposits (
     timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
-CREATE TABLE IF NOT EXISTS withdrawals (
+CREATE TABLE IF NOT EXISTS l2_bridge_withdrawals (
 	guid                VARCHAR PRIMARY KEY NOT NULL,
 
     -- Event causing this withdrawal
-    initiated_l2_event_guid VARCHAR NOT NULL REFERENCES l2_contract_events(guid),
-    sent_message_nonce      UINT256 UNIQUE,
+    initiated_l2_event_guid      VARCHAR NOT NULL REFERENCES l2_contract_events(guid),
+    cross_domain_messenger_nonce UINT256 UNIQUE,
 
     -- Multistep (bedrock) process of a withdrawal
     withdrawal_hash      VARCHAR NOT NULL,

indexer/processor/l1_processor.go

@@ -255,13 +255,13 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		return err
 	}
 
-	deposits := make([]*database.Deposit, len(initiatedDepositEvents))
+	deposits := make([]*database.L1BridgeDeposit, len(initiatedDepositEvents))
 	for i, initiatedBridgeEvent := range initiatedDepositEvents {
-		deposits[i] = &database.Deposit{
-			GUID:                 uuid.New(),
-			InitiatedL1EventGUID: initiatedBridgeEvent.RawEvent.GUID,
-			SentMessageNonce:     database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
-			TokenPair:            database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
+		deposits[i] = &database.L1BridgeDeposit{
+			GUID:                      uuid.New(),
+			InitiatedL1EventGUID:      initiatedBridgeEvent.RawEvent.GUID,
+			CrossDomainMessengerNonce: database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
+			TokenPair:                 database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
 			Tx: database.Transaction{
 				FromAddress: initiatedBridgeEvent.From,
 				ToAddress:   initiatedBridgeEvent.To,
@@ -274,7 +274,7 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 
 	if len(deposits) > 0 {
 		processLog.Info("detected L1StandardBridge deposits", "num", len(deposits))
-		err := db.Bridge.StoreDeposits(deposits)
+		err := db.BridgeTransfers.StoreL1BridgeDeposits(deposits)
 		if err != nil {
 			return err
 		}
@@ -286,47 +286,39 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		return err
 	}
 
-	// we manually keep track since not every proven withdrawal is a standard bridge withdrawal
+	latestL2Header, err := db.Blocks.LatestL2BlockHeader()
+	if err != nil {
+		return err
+	} else if len(provenWithdrawalEvents) > 0 && latestL2Header == nil {
+		return errors.New("no indexed L2 state to process any proven L1 transactions")
+	}
+
 	numProvenWithdrawals := 0
 	for _, provenWithdrawalEvent := range provenWithdrawalEvents {
 		withdrawalHash := provenWithdrawalEvent.WithdrawalHash
-		withdrawal, err := db.Bridge.WithdrawalByHash(withdrawalHash)
+		withdrawal, err := db.BridgeTransfers.L2BridgeWithdrawalByWithdrawalHash(withdrawalHash)
 		if err != nil {
 			return err
-		}
-
-		// Check if the L2Processor is behind or really has missed an event. We can compare against the
-		// OptimismPortal#ProvenWithdrawal on-chain mapping relative to the latest indexed L2 height
-		if withdrawal == nil {
-
-			// This needs to be updated to read from config as well as correctly identify if the CrossDomainMessenger message is a standard
-			// bridge message. This will easier to do once we index passed messages separately which will include the right To/From fields
+		} else if withdrawal == nil {
+			// NOTE: This needs to be updated to identify if this CrossDomainMessenger message is a StandardBridge message. This
+			// will be easier to do once we index cross domain messages and track its lifecyle separately
 			if provenWithdrawalEvent.From != common.HexToAddress("0x4200000000000000000000000000000000000007") || provenWithdrawalEvent.To != l1Contracts.L1CrossDomainMessenger {
 				// non-bridge withdrawal
 				continue
 			}
 
-			// Query for the the proven withdrawal on-chain
-			provenWithdrawal, err := OptimismPortalQueryProvenWithdrawal(rawEthClient, l1Contracts.OptimismPortal, withdrawalHash)
-			if err != nil {
-				return err
-			}
-
-			latestL2Header, err := db.Blocks.LatestL2BlockHeader()
-			if err != nil {
-				return err
-			}
-
-			if latestL2Header == nil || provenWithdrawal.L2OutputIndex.Cmp(latestL2Header.Number.Int) > 0 {
-				processLog.Warn("behind on indexed L2 withdrawals")
+			// Check if the L2Processor is behind or really has missed an event. Since L2 timestamps
+			// are derived from L1, we can simply compare timestamps
+			if provenWithdrawalEvent.RawEvent.Timestamp > latestL2Header.Timestamp {
+				processLog.Warn("behind on indexed L2StandardBridge withdrawals")
 				return errors.New("waiting for L2Processor to catch up")
 			} else {
-				processLog.Crit("missing indexed withdrawal for this proven event")
+				processLog.Crit("missing indexed L2StandardBridge withdrawal for this proven event")
 				return errors.New("missing withdrawal message")
 			}
 		}
 
-		err = db.Bridge.MarkProvenWithdrawalEvent(withdrawal.GUID, provenWithdrawalEvent.RawEvent.GUID)
+		err = db.BridgeTransfers.MarkProvenL2BridgeWithdrawalEvent(withdrawal.GUID, provenWithdrawalEvent.RawEvent.GUID)
 		if err != nil {
 			return err
 		}
@@ -346,7 +338,7 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 
 	for _, finalizedBridgeEvent := range finalizedWithdrawalEvents {
 		nonce := finalizedBridgeEvent.CrossDomainMessengerNonce
-		withdrawal, err := db.Bridge.WithdrawalByMessageNonce(nonce)
+		withdrawal, err := db.BridgeTransfers.L2BridgeWithdrawalByCrossDomainMessengerNonce(nonce)
 		if err != nil {
 			processLog.Error("error querying associated withdrawal messsage using nonce", "cross_domain_messenger_nonce", nonce)
 			return err
@@ -359,7 +351,7 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 			return errors.New("missing withdrawal message")
 		}
 
-		err = db.Bridge.MarkFinalizedWithdrawalEvent(withdrawal.GUID, finalizedBridgeEvent.RawEvent.GUID)
+		err = db.BridgeTransfers.MarkFinalizedL2BridgeWithdrawalEvent(withdrawal.GUID, finalizedBridgeEvent.RawEvent.GUID)
 		if err != nil {
 			processLog.Error("error finalizing withdrawal", "err", err)
 			return err

indexer/processor/l2_processor.go

@@ -183,7 +183,7 @@ func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		return err
 	}
 
-	withdrawals := make([]*database.Withdrawal, len(initiatedWithdrawalEvents))
+	withdrawals := make([]*database.L2BridgeWithdrawal, len(initiatedWithdrawalEvents))
 	for i, initiatedBridgeEvent := range initiatedWithdrawalEvents {
 		log := events.eventLog[initiatedBridgeEvent.RawEvent.GUID]
 
@@ -195,12 +195,12 @@ func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 			return err
 		}
 
-		withdrawals[i] = &database.Withdrawal{
-			GUID:                 uuid.New(),
-			InitiatedL2EventGUID: initiatedBridgeEvent.RawEvent.GUID,
-			SentMessageNonce:     database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
-			WithdrawalHash:       msgPassedData.WithdrawalHash,
-			TokenPair:            database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
+		withdrawals[i] = &database.L2BridgeWithdrawal{
+			GUID:                      uuid.New(),
+			InitiatedL2EventGUID:      initiatedBridgeEvent.RawEvent.GUID,
+			CrossDomainMessengerNonce: database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
+			WithdrawalHash:            msgPassedData.WithdrawalHash,
+			TokenPair:                 database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
 			Tx: database.Transaction{
 				FromAddress: initiatedBridgeEvent.From,
 				ToAddress:   initiatedBridgeEvent.To,
@@ -213,7 +213,7 @@ func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 
 	if len(withdrawals) > 0 {
 		processLog.Info("detected L2StandardBridge withdrawals", "num", len(withdrawals))
-		err := db.Bridge.StoreWithdrawals(withdrawals)
+		err := db.BridgeTransfers.StoreL2BridgeWithdrawals(withdrawals)
 		if err != nil {
 			return err
 		}
@@ -225,30 +225,33 @@ func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		return err
 	}
 
+	latestL1Header, err := db.Blocks.LatestL1BlockHeader()
+	if err != nil {
+		return err
+	} else if len(finalizationBridgeEvents) > 0 && latestL1Header == nil {
+		return errors.New("no indexed L1 state to process any L2 bridge finalizations")
+	}
+
 	for _, finalizedBridgeEvent := range finalizationBridgeEvents {
 		nonce := finalizedBridgeEvent.CrossDomainMessengerNonce
 
-		deposit, err := db.Bridge.DepositByMessageNonce(nonce)
+		deposit, err := db.BridgeTransfers.L1BridgeDepositByCrossDomainMessengerNonce(nonce)
 		if err != nil {
 			processLog.Error("error querying associated deposit messsage using nonce", "cross_domain_messenger_nonce", nonce)
 			return err
 		} else if deposit == nil {
-			latestNonce, err := db.Bridge.LatestDepositMessageNonce()
-			if err != nil {
-				return err
-			}
-
-			// Check if the L1Processor is behind or really has missed an event
-			if latestNonce == nil || nonce.Cmp(latestNonce) > 0 {
-				processLog.Warn("behind on indexed L1 deposits")
+			// Check if the L1Processor is behind or really has missed an event. Since L2 timestamps
+			// are derived from L1, we can simply compare timestamps
+			if finalizedBridgeEvent.RawEvent.Timestamp > latestL1Header.Timestamp {
+				processLog.Warn("behind on indexed L1StandardBridge deposits")
 				return errors.New("waiting for L1Processor to catch up")
 			} else {
-				processLog.Crit("missing indexed deposit for this finalization event")
+				processLog.Crit("missing indexed L1StandardBridge deposit for this finalization event")
 				return errors.New("missing deposit message")
 			}
 		}
 
-		err = db.Bridge.MarkFinalizedDepositEvent(deposit.GUID, finalizedBridgeEvent.RawEvent.GUID)
+		err = db.BridgeTransfers.MarkFinalizedL1BridgeDepositEvent(deposit.GUID, finalizedBridgeEvent.RawEvent.GUID)
 		if err != nil {
 			processLog.Error("error finalizing deposit", "err", err)
 			return err