Merge branch 'develop' into aj/cannon-network

indexer/api/api_test.go

@@ -8,32 +8,25 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 )
 
 // MockBridgeTransfersView mocks the BridgeTransfersView interface
 type MockBridgeTransfersView struct{}
 
-const (
-	guid1 = "8408b6d2-7c90-4cfc-8604-b2204116cb6a"
-	guid2 = "8408b6d2-7c90-4cfc-8604-b2204116cb6b"
-)
-
 var (
 	deposit = database.L1BridgeDeposit{
-		GUID:                 uuid.MustParse(guid1),
-		InitiatedL1EventGUID: uuid.MustParse(guid2),
-		Tx:                   database.Transaction{},
-		TokenPair:            database.TokenPair{},
+		TransactionSourceHash:     common.HexToHash("abc"),
+		CrossDomainMessengerNonce: &database.U256{Int: big.NewInt(0)},
+		Tx:                        database.Transaction{},
+		TokenPair:                 database.TokenPair{},
 	}
 
 	withdrawal = database.L2BridgeWithdrawal{
-		GUID:                 uuid.MustParse(guid2),
-		InitiatedL2EventGUID: uuid.MustParse(guid1),
-		WithdrawalHash:       common.HexToHash("0x456"),
-		Tx:                   database.Transaction{},
-		TokenPair:            database.TokenPair{},
+		TransactionWithdrawalHash: common.HexToHash("0x456"),
+		CrossDomainMessengerNonce: &database.U256{Int: big.NewInt(0)},
+		Tx:                        database.Transaction{},
+		TokenPair:                 database.TokenPair{},
 	}
 )
 
@@ -54,7 +47,7 @@ func (mbv *MockBridgeTransfersView) L1BridgeDepositsByAddress(address common.Add
 	}, nil
 }
 
-func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalByWithdrawalHash(address common.Hash) (*database.L2BridgeWithdrawal, error) {
+func (mbv *MockBridgeTransfersView) L2BridgeWithdrawal(address common.Hash) (*database.L2BridgeWithdrawal, error) {
 	return &withdrawal, nil
 }
 

indexer/database/bridge_messages.go

+package database
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+
+	"gorm.io/gorm"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/google/uuid"
+)
+
+/**
+ * Types
+ */
+
+type BridgeMessage struct {
+	Nonce       U256        `gorm:"primaryKey"`
+	MessageHash common.Hash `gorm:"serializer:json"`
+
+	SentMessageEventGUID    uuid.UUID
+	RelayedMessageEventGUID *uuid.UUID
+
+	Tx       Transaction `gorm:"embedded"`
+	GasLimit U256
+}
+
+type L1BridgeMessage struct {
+	BridgeMessage         `gorm:"embedded"`
+	TransactionSourceHash common.Hash `gorm:"serializer:json"`
+}
+
+type L2BridgeMessage struct {
+	BridgeMessage             `gorm:"embedded"`
+	TransactionWithdrawalHash common.Hash `gorm:"serializer:json"`
+}
+
+type BridgeMessagesView interface {
+	L1BridgeMessage(*big.Int) (*L1BridgeMessage, error)
+	L1BridgeMessageByHash(common.Hash) (*L1BridgeMessage, error)
+	LatestL1BridgeMessageNonce() (*big.Int, error)
+
+	L2BridgeMessage(*big.Int) (*L2BridgeMessage, error)
+	L2BridgeMessageByHash(common.Hash) (*L2BridgeMessage, error)
+	LatestL2BridgeMessageNonce() (*big.Int, error)
+}
+
+type BridgeMessagesDB interface {
+	BridgeMessagesView
+
+	StoreL1BridgeMessages([]*L1BridgeMessage) error
+	MarkRelayedL1BridgeMessage(common.Hash, uuid.UUID) error
+
+	StoreL2BridgeMessages([]*L2BridgeMessage) error
+	MarkRelayedL2BridgeMessage(common.Hash, uuid.UUID) error
+}
+
+/**
+ * Implementation
+ */
+
+type bridgeMessagesDB struct {
+	gorm *gorm.DB
+}
+
+func newBridgeMessagesDB(db *gorm.DB) BridgeMessagesDB {
+	return &bridgeMessagesDB{gorm: db}
+}
+
+/**
+ * Arbitrary Messages Sent from L1
+ */
+
+func (db bridgeMessagesDB) StoreL1BridgeMessages(messages []*L1BridgeMessage) error {
+	result := db.gorm.Create(&messages)
+	return result.Error
+}
+
+func (db bridgeMessagesDB) L1BridgeMessage(nonce *big.Int) (*L1BridgeMessage, error) {
+	var sentMessage L1BridgeMessage
+	result := db.gorm.Where(&BridgeMessage{Nonce: U256{Int: nonce}}).Take(&sentMessage)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &sentMessage, nil
+}
+
+func (db bridgeMessagesDB) L1BridgeMessageByHash(messageHash common.Hash) (*L1BridgeMessage, error) {
+	var sentMessage L1BridgeMessage
+	result := db.gorm.Where(&BridgeMessage{MessageHash: messageHash}).Take(&sentMessage)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &sentMessage, nil
+}
+
+func (db bridgeMessagesDB) LatestL1BridgeMessageNonce() (*big.Int, error) {
+	var sentMessage L1BridgeMessage
+	result := db.gorm.Order("nonce DESC").Take(&sentMessage)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return sentMessage.Nonce.Int, nil
+}
+
+/**
+ * Arbitrary Messages Sent from L2
+ */
+
+func (db bridgeMessagesDB) MarkRelayedL1BridgeMessage(messageHash common.Hash, relayEvent uuid.UUID) error {
+	message, err := db.L1BridgeMessageByHash(messageHash)
+	if err != nil {
+		return err
+	} else if message == nil {
+		return fmt.Errorf("L1BridgeMessage with message hash %s not found", messageHash)
+	}
+
+	message.RelayedMessageEventGUID = &relayEvent
+	result := db.gorm.Save(message)
+	return result.Error
+}
+
+func (db bridgeMessagesDB) StoreL2BridgeMessages(messages []*L2BridgeMessage) error {
+	result := db.gorm.Create(&messages)
+	return result.Error
+}
+
+func (db bridgeMessagesDB) L2BridgeMessage(nonce *big.Int) (*L2BridgeMessage, error) {
+	var sentMessage L2BridgeMessage
+	result := db.gorm.Where(&BridgeMessage{Nonce: U256{Int: nonce}}).Take(&sentMessage)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &sentMessage, nil
+}
+
+func (db bridgeMessagesDB) L2BridgeMessageByHash(messageHash common.Hash) (*L2BridgeMessage, error) {
+	var sentMessage L2BridgeMessage
+	result := db.gorm.Where(&BridgeMessage{MessageHash: messageHash}).Take(&sentMessage)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &sentMessage, nil
+}
+
+func (db bridgeMessagesDB) LatestL2BridgeMessageNonce() (*big.Int, error) {
+	var sentMessage L2BridgeMessage
+	result := db.gorm.Order("nonce DESC").Take(&sentMessage)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return sentMessage.Nonce.Int, nil
+}
+
+func (db bridgeMessagesDB) MarkRelayedL2BridgeMessage(messageHash common.Hash, relayEvent uuid.UUID) error {
+	message, err := db.L2BridgeMessageByHash(messageHash)
+	if err != nil {
+		return err
+	} else if message == nil {
+		return fmt.Errorf("L2BridgeMessage with message hash %s not found", messageHash)
+	}
+
+	message.RelayedMessageEventGUID = &relayEvent
+	result := db.gorm.Save(message)
+	return result.Error
+}

indexer/database/bridge_transactions.go

+package database
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+/**
+ * Types
+ */
+
+type Transaction struct {
+	FromAddress common.Address `gorm:"serializer:json"`
+	ToAddress   common.Address `gorm:"serializer:json"`
+	Amount      U256
+	Data        hexutil.Bytes `gorm:"serializer:json"`
+	Timestamp   uint64
+}
+
+type L1TransactionDeposit struct {
+	SourceHash        common.Hash `gorm:"serializer:json;primaryKey"`
+	L2TransactionHash common.Hash `gorm:"serializer:json"`
+
+	InitiatedL1EventGUID uuid.UUID
+
+	Version    U256
+	OpaqueData hexutil.Bytes `gorm:"serializer:json"`
+
+	Tx       Transaction `gorm:"embedded"`
+	GasLimit U256
+}
+
+type L2TransactionWithdrawal struct {
+	WithdrawalHash common.Hash `gorm:"serializer:json;primaryKey"`
+
+	Nonce                U256
+	InitiatedL2EventGUID uuid.UUID
+
+	ProvenL1EventGUID    *uuid.UUID
+	FinalizedL1EventGUID *uuid.UUID
+	Succeeded            *bool
+
+	Tx       Transaction `gorm:"embedded"`
+	GasLimit U256
+}
+
+type BridgeTransactionsView interface {
+	L1TransactionDeposit(common.Hash) (*L1TransactionDeposit, error)
+	L2TransactionWithdrawal(common.Hash) (*L2TransactionWithdrawal, error)
+}
+
+type BridgeTransactionsDB interface {
+	BridgeTransactionsView
+
+	StoreL1TransactionDeposits([]*L1TransactionDeposit) error
+
+	StoreL2TransactionWithdrawals([]*L2TransactionWithdrawal) error
+	MarkL2TransactionWithdrawalProvenEvent(common.Hash, uuid.UUID) error
+	MarkL2TransactionWithdrawalFinalizedEvent(common.Hash, uuid.UUID, bool) error
+}
+
+/**
+ * Implementation
+ */
+
+type bridgeTransactionsDB struct {
+	gorm *gorm.DB
+}
+
+func newBridgeTransactionsDB(db *gorm.DB) BridgeTransactionsDB {
+	return &bridgeTransactionsDB{gorm: db}
+}
+
+/**
+ * Transactions deposited from L1
+ */
+
+func (db *bridgeTransactionsDB) StoreL1TransactionDeposits(deposits []*L1TransactionDeposit) error {
+	result := db.gorm.Create(&deposits)
+	return result.Error
+}
+
+func (db *bridgeTransactionsDB) L1TransactionDeposit(sourceHash common.Hash) (*L1TransactionDeposit, error) {
+	var deposit L1TransactionDeposit
+	result := db.gorm.Where(&L1TransactionDeposit{SourceHash: sourceHash}).Take(&deposit)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &deposit, nil
+}
+
+/**
+ * Transactions withdrawn from L2
+ */
+
+func (db *bridgeTransactionsDB) StoreL2TransactionWithdrawals(withdrawals []*L2TransactionWithdrawal) error {
+	result := db.gorm.Create(&withdrawals)
+	return result.Error
+}
+
+func (db *bridgeTransactionsDB) L2TransactionWithdrawal(withdrawalHash common.Hash) (*L2TransactionWithdrawal, error) {
+	var withdrawal L2TransactionWithdrawal
+	result := db.gorm.Where(&L2TransactionWithdrawal{WithdrawalHash: withdrawalHash}).Take(&withdrawal)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &withdrawal, nil
+}
+
+// MarkL2TransactionWithdrawalProvenEvent links a withdrawn transaction with associated Prove action on L1.
+func (db *bridgeTransactionsDB) MarkL2TransactionWithdrawalProvenEvent(withdrawalHash common.Hash, provenL1EventGuid uuid.UUID) error {
+	withdrawal, err := db.L2TransactionWithdrawal(withdrawalHash)
+	if err != nil {
+		return err
+	}
+	if withdrawal == nil {
+		return fmt.Errorf("transaction withdrawal hash %s not found", withdrawalHash)
+	}
+
+	withdrawal.ProvenL1EventGUID = &provenL1EventGuid
+	result := db.gorm.Save(&withdrawal)
+	return result.Error
+}
+
+// MarkL2TransactionWithdrawalProvenEvent links a withdrawn transaction in its finalized state
+func (db *bridgeTransactionsDB) MarkL2TransactionWithdrawalFinalizedEvent(withdrawalHash common.Hash, finalizedL1EventGuid uuid.UUID, succeeded bool) error {
+	withdrawal, err := db.L2TransactionWithdrawal(withdrawalHash)
+	if err != nil {
+		return err
+	}
+	if withdrawal == nil {
+		return fmt.Errorf("transaction withdrawal hash %s not found", withdrawalHash)
+	}
+	if withdrawal.ProvenL1EventGUID == nil {
+		return fmt.Errorf("cannot mark unproven withdrawal hash %s as finalized", withdrawal.WithdrawalHash)
+	}
+
+	withdrawal.FinalizedL1EventGUID = &finalizedL1EventGuid
+	withdrawal.Succeeded = &succeeded
+	result := db.gorm.Save(&withdrawal)
+	return result.Error
+}

indexer/database/db.go

@@ -10,9 +10,11 @@ import (
 type DB struct {
 	gorm *gorm.DB
 
-	Blocks          BlocksDB
-	ContractEvents  ContractEventsDB
-	BridgeTransfers BridgeTransfersDB
+	Blocks             BlocksDB
+	ContractEvents     ContractEventsDB
+	BridgeTransfers    BridgeTransfersDB
+	BridgeMessages     BridgeMessagesDB
+	BridgeTransactions BridgeTransactionsDB
 }
 
 func NewDB(dsn string) (*DB, error) {
@@ -31,10 +33,12 @@ func NewDB(dsn string) (*DB, error) {
 	}
 
 	db := &DB{
-		gorm:            gorm,
-		Blocks:          newBlocksDB(gorm),
-		ContractEvents:  newContractEventsDB(gorm),
-		BridgeTransfers: newBridgeTransfersDB(gorm),
+		gorm:               gorm,
+		Blocks:             newBlocksDB(gorm),
+		ContractEvents:     newContractEventsDB(gorm),
+		BridgeTransfers:    newBridgeTransfersDB(gorm),
+		BridgeMessages:     newBridgeMessagesDB(gorm),
+		BridgeTransactions: newBridgeTransactionsDB(gorm),
 	}
 
 	return db, nil
@@ -59,9 +63,11 @@ func (db *DB) Close() error {
 
 func dbFromGormTx(tx *gorm.DB) *DB {
 	return &DB{
-		gorm:            tx,
-		Blocks:          newBlocksDB(tx),
-		ContractEvents:  newContractEventsDB(tx),
-		BridgeTransfers: newBridgeTransfersDB(tx),
+		gorm:               tx,
+		Blocks:             newBlocksDB(tx),
+		ContractEvents:     newContractEventsDB(tx),
+		BridgeTransfers:    newBridgeTransfersDB(tx),
+		BridgeMessages:     newBridgeMessagesDB(tx),
+		BridgeTransactions: newBridgeTransactionsDB(tx),
 	}
 }

indexer/e2e_tests/bridge_messages_e2e_test.go

+package e2e_tests
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	e2etest_utils "github.com/ethereum-optimism/optimism/indexer/e2e_tests/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/withdrawals"
+	"github.com/ethereum-optimism/optimism/op-service/client/utils"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/params"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestE2EBridgeL1CrossDomainMessenger(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+
+	l1CrossDomainMessenger, err := bindings.NewL1CrossDomainMessenger(testSuite.OpCfg.L1Deployments.L1CrossDomainMessengerProxy, testSuite.L1Client)
+	require.NoError(t, err)
+
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+
+	// Attach 1ETH and random calldata to the sent messages
+	calldata := []byte{byte(1), byte(2), byte(3)}
+	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
+	require.NoError(t, err)
+	l1Opts.Value = big.NewInt(params.Ether)
+
+	// Pause the processor to track relayed event
+	testSuite.Indexer.L2Processor.PauseForTest()
+
+	// (1) Send the Message
+	sentMsgTx, err := l1CrossDomainMessenger.SendMessage(l1Opts, aliceAddr, calldata, 100_000)
+	require.NoError(t, err)
+	sentMsgReceipt, err := utils.WaitReceiptOK(context.Background(), testSuite.L1Client, sentMsgTx.Hash())
+	require.NoError(t, err)
+
+	depositInfo, err := e2etest_utils.ParseDepositInfo(sentMsgReceipt)
+	require.NoError(t, err)
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= sentMsgReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	parsedMessage, err := e2etest_utils.ParseCrossDomainMessage(sentMsgReceipt)
+	require.NoError(t, err)
+
+	// nonce for this message is zero but the current cross domain message version is 1.
+	nonceBytes := [31]byte{0: byte(1)}
+	nonce := new(big.Int).SetBytes(nonceBytes[:])
+
+	sentMessage, err := testSuite.DB.BridgeMessages.L1BridgeMessage(nonce)
+	require.NoError(t, err)
+	require.NotNil(t, sentMessage)
+	require.NotNil(t, sentMessage.SentMessageEventGUID)
+	require.Equal(t, depositInfo.DepositTx.SourceHash, sentMessage.TransactionSourceHash)
+	require.Equal(t, parsedMessage.MessageHash, sentMessage.MessageHash)
+	require.Equal(t, uint64(100_000), sentMessage.GasLimit.Int.Uint64())
+	require.Equal(t, big.NewInt(params.Ether), sentMessage.Tx.Amount.Int)
+	require.Equal(t, aliceAddr, sentMessage.Tx.FromAddress)
+	require.Equal(t, aliceAddr, sentMessage.Tx.ToAddress)
+	require.ElementsMatch(t, calldata, sentMessage.Tx.Data)
+
+	// (2) Process RelayedMesssage on inclusion
+	require.Nil(t, sentMessage.RelayedMessageEventGUID)
+	testSuite.Indexer.L2Processor.ResumeForTest()
+	transaction, err := testSuite.DB.BridgeTransactions.L1TransactionDeposit(sentMessage.TransactionSourceHash)
+	require.NoError(t, err)
+
+	// wait for processor catchup
+	depositReceipt, err := utils.WaitReceiptOK(context.Background(), testSuite.L2Client, transaction.L2TransactionHash)
+	require.NoError(t, err)
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		return l2Header != nil && l2Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	sentMessage, err = testSuite.DB.BridgeMessages.L1BridgeMessage(nonce)
+	require.NoError(t, err)
+	require.NotNil(t, sentMessage)
+	require.NotNil(t, sentMessage.RelayedMessageEventGUID)
+
+	event, err := testSuite.DB.ContractEvents.L2ContractEvent(*sentMessage.RelayedMessageEventGUID)
+	require.NoError(t, err)
+	require.NotNil(t, event)
+	require.Equal(t, event.TransactionHash, transaction.L2TransactionHash)
+}
+
+func TestE2EBridgeL2CrossDomainMessenger(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+
+	optimismPortal, err := bindings.NewOptimismPortal(testSuite.OpCfg.L1Deployments.OptimismPortalProxy, testSuite.L1Client)
+	require.NoError(t, err)
+	l2CrossDomainMessenger, err := bindings.NewL2CrossDomainMessenger(predeploys.L2CrossDomainMessengerAddr, testSuite.L2Client)
+	require.NoError(t, err)
+
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+
+	// Attach 1ETH and random calldata to the sent messages
+	calldata := []byte{byte(1), byte(2), byte(3)}
+	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(context.Background(), testSuite.L1Client, depositTx.Hash())
+	require.NoError(t, err)
+
+	// (1) Send the Message
+	sentMsgTx, err := l2CrossDomainMessenger.SendMessage(l2Opts, aliceAddr, calldata, 100_000)
+	require.NoError(t, err)
+	sentMsgReceipt, err := utils.WaitReceiptOK(context.Background(), testSuite.L2Client, sentMsgTx.Hash())
+	require.NoError(t, err)
+
+	msgPassed, err := withdrawals.ParseMessagePassed(sentMsgReceipt)
+	require.NoError(t, err)
+	withdrawalHash, err := withdrawals.WithdrawalHash(msgPassed)
+	require.NoError(t, err)
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		return l2Header != nil && l2Header.Number.Uint64() >= sentMsgReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	parsedMessage, err := e2etest_utils.ParseCrossDomainMessage(sentMsgReceipt)
+	require.NoError(t, err)
+
+	// nonce for this message is zero but the current message version is 1.
+	nonceBytes := [31]byte{0: byte(1)}
+	nonce := new(big.Int).SetBytes(nonceBytes[:])
+
+	sentMessage, err := testSuite.DB.BridgeMessages.L2BridgeMessage(nonce)
+	require.NoError(t, err)
+	require.NotNil(t, sentMessage)
+	require.NotNil(t, sentMessage.SentMessageEventGUID)
+	require.Equal(t, withdrawalHash, sentMessage.TransactionWithdrawalHash)
+	require.Equal(t, parsedMessage.MessageHash, sentMessage.MessageHash)
+	require.Equal(t, uint64(100_000), sentMessage.GasLimit.Int.Uint64())
+	require.Equal(t, big.NewInt(params.Ether), sentMessage.Tx.Amount.Int)
+	require.Equal(t, aliceAddr, sentMessage.Tx.FromAddress)
+	require.Equal(t, aliceAddr, sentMessage.Tx.ToAddress)
+	require.ElementsMatch(t, calldata, sentMessage.Tx.Data)
+
+	// (2) Process RelayedMessage on withdrawal finalization
+	require.Nil(t, sentMessage.RelayedMessageEventGUID)
+	_, finalizedReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, sentMsgReceipt)
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= finalizedReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	// message is marked as relayed
+	sentMessage, err = testSuite.DB.BridgeMessages.L2BridgeMessage(nonce)
+	require.NoError(t, err)
+	require.NotNil(t, sentMessage)
+	require.NotNil(t, sentMessage.RelayedMessageEventGUID)
+
+	event, err := testSuite.DB.ContractEvents.L1ContractEvent(*sentMessage.RelayedMessageEventGUID)
+	require.NoError(t, err)
+	require.NotNil(t, event)
+	require.Equal(t, event.TransactionHash, finalizedReceipt.TxHash)
+}

indexer/e2e_tests/bridge_transactions_e2e_test.go

+package e2e_tests
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	e2etest_utils "github.com/ethereum-optimism/optimism/indexer/e2e_tests/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/withdrawals"
+	"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 TestE2EBridgeTransactionsOptimismPortalDeposits(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+
+	optimismPortal, err := bindings.NewOptimismPortal(testSuite.OpCfg.L1Deployments.OptimismPortalProxy, testSuite.L1Client)
+	require.NoError(t, err)
+
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+
+	// attach 1 ETH to the deposit and random calldata
+	calldata := []byte{byte(1), byte(2), byte(3)}
+	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
+	require.NoError(t, err)
+	l1Opts.Value = big.NewInt(params.Ether)
+
+	depositTx, err := optimismPortal.DepositTransaction(l1Opts, aliceAddr, l1Opts.Value, 100_000, false, calldata)
+	require.NoError(t, err)
+	depositReceipt, err := utils.WaitReceiptOK(context.Background(), testSuite.L1Client, depositTx.Hash())
+	require.NoError(t, err)
+
+	depositInfo, err := e2etest_utils.ParseDepositInfo(depositReceipt)
+	require.NoError(t, err)
+
+	depositL2TxHash := types.NewTx(depositInfo.DepositTx).Hash()
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	deposit, err := testSuite.DB.BridgeTransactions.L1TransactionDeposit(depositInfo.DepositTx.SourceHash)
+	require.NoError(t, err)
+	require.Equal(t, depositL2TxHash, deposit.L2TransactionHash)
+	require.Equal(t, big.NewInt(100_000), deposit.GasLimit.Int)
+	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.ElementsMatch(t, calldata, deposit.Tx.Data)
+
+	require.Equal(t, depositInfo.Version.Uint64(), deposit.Version.Int.Uint64())
+	require.ElementsMatch(t, depositInfo.OpaqueData, deposit.OpaqueData)
+
+	event, err := testSuite.DB.ContractEvents.L1ContractEvent(deposit.InitiatedL1EventGUID)
+	require.NoError(t, err)
+	require.NotNil(t, event)
+	require.Equal(t, event.TransactionHash, depositTx.Hash())
+
+	// NOTE: The indexer does not track deposit inclusion as it's apart of the block derivation process.
+	// If this changes, we'd like to test for this here.
+}
+
+func TestE2EBridgeTransactionsL2ToL1MessagePasserWithdrawal(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+
+	optimismPortal, err := bindings.NewOptimismPortal(testSuite.OpCfg.L1Deployments.OptimismPortalProxy, testSuite.L1Client)
+	require.NoError(t, err)
+	l2ToL1MessagePasser, err := bindings.NewL2ToL1MessagePasser(predeploys.L2ToL1MessagePasserAddr, testSuite.L2Client)
+	require.NoError(t, err)
+
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+
+	// attach 1 ETH to the withdrawal and random calldata
+	calldata := []byte{byte(1), byte(2), byte(3)}
+	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(context.Background(), testSuite.L1Client, depositTx.Hash())
+	require.NoError(t, err)
+
+	withdrawTx, err := l2ToL1MessagePasser.InitiateWithdrawal(l2Opts, aliceAddr, big.NewInt(100_000), calldata)
+	require.NoError(t, err)
+	withdrawReceipt, err := utils.WaitReceiptOK(context.Background(), testSuite.L2Client, withdrawTx.Hash())
+	require.NoError(t, err)
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		return l2Header != nil && l2Header.Number.Uint64() >= withdrawReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	msgPassed, err := withdrawals.ParseMessagePassed(withdrawReceipt)
+	require.NoError(t, err)
+	withdrawalHash, err := withdrawals.WithdrawalHash(msgPassed)
+	require.NoError(t, err)
+
+	withdraw, err := testSuite.DB.BridgeTransactions.L2TransactionWithdrawal(withdrawalHash)
+	require.NoError(t, err)
+	require.Equal(t, msgPassed.Nonce.Uint64(), withdraw.Nonce.Int.Uint64())
+	require.Equal(t, big.NewInt(100_000), withdraw.GasLimit.Int)
+	require.Equal(t, big.NewInt(params.Ether), withdraw.Tx.Amount.Int)
+	require.Equal(t, aliceAddr, withdraw.Tx.FromAddress)
+	require.Equal(t, aliceAddr, withdraw.Tx.ToAddress)
+	require.ElementsMatch(t, calldata, withdraw.Tx.Data)
+
+	event, err := testSuite.DB.ContractEvents.L2ContractEvent(withdraw.InitiatedL2EventGUID)
+	require.NoError(t, err)
+	require.NotNil(t, event)
+	require.Equal(t, event.TransactionHash, withdrawTx.Hash())
+
+	// Test Withdrawal Proven
+	require.Nil(t, withdraw.ProvenL1EventGUID)
+	require.Nil(t, withdraw.FinalizedL1EventGUID)
+
+	withdrawParams, proveReceipt := op_e2e.ProveWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= proveReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	withdraw, err = testSuite.DB.BridgeTransactions.L2TransactionWithdrawal(withdrawalHash)
+	require.NoError(t, err)
+	require.NotNil(t, withdraw.ProvenL1EventGUID)
+
+	proveEvent, err := testSuite.DB.ContractEvents.L1ContractEvent(*withdraw.ProvenL1EventGUID)
+	require.NoError(t, err)
+	require.NotNil(t, event)
+	require.Equal(t, proveEvent.TransactionHash, proveReceipt.TxHash)
+
+	// Test Withdrawal Finalized
+	require.Nil(t, withdraw.FinalizedL1EventGUID)
+
+	finalizeReceipt := op_e2e.FinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpCfg.Secrets.Alice, proveReceipt, withdrawParams)
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	withdraw, err = testSuite.DB.BridgeTransactions.L2TransactionWithdrawal(withdrawalHash)
+	require.NoError(t, err)
+	require.NotNil(t, withdraw.FinalizedL1EventGUID)
+	require.NotNil(t, withdraw.Succeeded)
+	require.True(t, *withdraw.Succeeded)
+
+	finalizedEvent, err := testSuite.DB.ContractEvents.L1ContractEvent(*withdraw.FinalizedL1EventGUID)
+	require.NoError(t, err)
+	require.NotNil(t, event)
+	require.Equal(t, finalizedEvent.TransactionHash, finalizeReceipt.TxHash)
+}
+
+func TestE2EBridgeTransactionsL2ToL1MessagePasserFailedWithdrawal(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+
+	l2ToL1MessagePasser, err := bindings.NewL2ToL1MessagePasser(predeploys.L2ToL1MessagePasserAddr, testSuite.L2Client)
+	require.NoError(t, err)
+
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+
+	// Try to withdraw 1 ETH from L2 without any corresponding deposits on L1
+	l2Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L2ChainIDBig())
+	require.NoError(t, err)
+	l2Opts.Value = big.NewInt(params.Ether)
+
+	withdrawTx, err := l2ToL1MessagePasser.InitiateWithdrawal(l2Opts, aliceAddr, big.NewInt(100_000), nil)
+	require.NoError(t, err)
+	withdrawReceipt, err := utils.WaitReceiptOK(context.Background(), testSuite.L2Client, withdrawTx.Hash())
+	require.NoError(t, err)
+
+	msgPassed, err := withdrawals.ParseMessagePassed(withdrawReceipt)
+	require.NoError(t, err)
+	withdrawalHash, err := withdrawals.WithdrawalHash(msgPassed)
+	require.NoError(t, err)
+
+	// Prove&Finalize withdrawal
+	_, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	// Withdrawal registered but marked as unsuccessful
+	withdraw, err := testSuite.DB.BridgeTransactions.L2TransactionWithdrawal(withdrawalHash)
+	require.NoError(t, err)
+	require.NotNil(t, withdraw.Succeeded)
+	require.False(t, *withdraw.Succeeded)
+}

indexer/e2e_tests/setup.go

@@ -53,6 +53,10 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 	opSys, err := opCfg.Start()
 	require.NoError(t, err)
 
+	// E2E tests can run on the order of magnitude of minutes. Once
+	// the system is running, mark this test for Parallel execution
+	t.Parallel()
+
 	// Indexer Configuration and Start
 	indexerCfg := config.Config{
 		Logger: logger,
@@ -82,21 +86,19 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 	indexer, err := indexer.NewIndexer(indexerCfg)
 	require.NoError(t, err)
 
+	indexerStoppedCh := make(chan interface{}, 1)
 	indexerCtx, indexerStop := context.WithCancel(context.Background())
 	go func() {
 		err := indexer.Run(indexerCtx)
 		require.NoError(t, err)
-
-		indexer.Cleanup()
+		indexerStoppedCh <- nil
 	}()
 
 	t.Cleanup(func() {
 		indexerStop()
+		<-indexerStoppedCh
 
-		// wait a second for the stop signal to be received
-		time.Sleep(1 * time.Second)
 		indexer.Cleanup()
-
 		db.Close()
 		opSys.Close()
 	})
@@ -114,6 +116,8 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 
 func setupTestDatabase(t *testing.T) string {
 	user := os.Getenv("DB_USER")
+	require.NotEmpty(t, user, "DB_USER env variable expected to instantiate test database")
+
 	pg, err := sql.Open("pgx", fmt.Sprintf("postgres://%s@localhost:5432?sslmode=disable", user))
 	require.NoError(t, err)
 	require.NoError(t, pg.Ping())

indexer/e2e_tests/utils/cross_domain_messages.go

+package utils
+
+import (
+	"errors"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/processor"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type CrossDomainMessengerSentMessage struct {
+	*bindings.CrossDomainMessengerSentMessage
+	Value       *big.Int
+	MessageHash common.Hash
+}
+
+func ParseCrossDomainMessage(sentMessageReceipt *types.Receipt) (CrossDomainMessengerSentMessage, error) {
+	abi, err := bindings.CrossDomainMessengerMetaData.GetAbi()
+	if err != nil {
+		return CrossDomainMessengerSentMessage{}, err
+	}
+
+	sentMessageEventAbi := abi.Events["SentMessage"]
+	messenger, err := bindings.NewCrossDomainMessenger(common.Address{}, nil)
+	if err != nil {
+		return CrossDomainMessengerSentMessage{}, err
+	}
+
+	for i, log := range sentMessageReceipt.Logs {
+		if len(log.Topics) > 0 && log.Topics[0] == sentMessageEventAbi.ID {
+			sentMessage, err := messenger.ParseSentMessage(*log)
+			if err != nil {
+				return CrossDomainMessengerSentMessage{}, err
+			}
+			sentMessageExtension, err := messenger.ParseSentMessageExtension1(*sentMessageReceipt.Logs[i+1])
+			if err != nil {
+				return CrossDomainMessengerSentMessage{}, err
+			}
+			msgHash, err := CrossDomainMessengerSentMessageHash(sentMessage, sentMessageExtension.Value)
+			if err != nil {
+				return CrossDomainMessengerSentMessage{}, err
+			}
+
+			return CrossDomainMessengerSentMessage{sentMessage, sentMessageExtension.Value, msgHash}, nil
+		}
+	}
+
+	return CrossDomainMessengerSentMessage{}, errors.New("missing SentMessage receipts")
+}
+
+func CrossDomainMessengerSentMessageHash(sentMessage *bindings.CrossDomainMessengerSentMessage, value *big.Int) (common.Hash, error) {
+	abi, err := bindings.CrossDomainMessengerMetaData.GetAbi()
+	if err != nil {
+		return common.Hash{}, err
+	}
+
+	return processor.CrossDomainMessageHash(abi, sentMessage, value)
+}

indexer/migrations/20230523_create_schema.sql

 
-CREATE DOMAIN UINT256 AS NUMERIC NOT NULL
+CREATE DOMAIN UINT256 AS NUMERIC
     CHECK (VALUE >= 0 AND VALUE < 2^256 and SCALE(VALUE) = 0);
 
 /**
@@ -9,7 +9,7 @@ CREATE DOMAIN UINT256 AS NUMERIC NOT NULL
 CREATE TABLE IF NOT EXISTS l1_block_headers (
 	hash        VARCHAR NOT NULL PRIMARY KEY,
 	parent_hash VARCHAR NOT NULL,
-	number      UINT256,
+	number      UINT256 NOT NULL,
 	timestamp   INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
@@ -17,7 +17,7 @@ CREATE TABLE IF NOT EXISTS l2_block_headers (
     -- Block header
 	hash                     VARCHAR NOT NULL PRIMARY KEY,
 	parent_hash              VARCHAR NOT NULL,
-	number                   UINT256,
+	number                   UINT256 NOT NULL,
 	timestamp                INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
@@ -57,8 +57,8 @@ CREATE TABLE IF NOT EXISTS legacy_state_batches (
 CREATE TABLE IF NOT EXISTS output_proposals (
     output_root     VARCHAR NOT NULL PRIMARY KEY,
 
-    l2_output_index UINT256,
-    l2_block_number UINT256,
+    l2_output_index UINT256 NOT NULL,
+    l2_block_number UINT256 NOT NULL,
 
     l1_contract_event_guid VARCHAR REFERENCES l1_contract_events(guid)
 );
@@ -67,47 +67,111 @@ CREATE TABLE IF NOT EXISTS output_proposals (
  * BRIDGING DATA
  */
 
-CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
-	guid                 VARCHAR PRIMARY KEY NOT NULL,
+-- OptimismPortal/L2ToL1MessagePasser
+CREATE TABLE IF NOT EXISTS l1_transaction_deposits (
+    source_hash         VARCHAR NOT NULL PRIMARY KEY,
+    l2_transaction_hash VARCHAR NOT NULL,
 
-    -- Event causing the deposit
-    initiated_l1_event_guid      VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
-    cross_domain_messenger_nonce UINT256 UNIQUE,
+    initiated_l1_event_guid VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
 
-    -- Finalization marker for the deposit
-    finalized_l2_event_guid VARCHAR REFERENCES l2_contract_events(guid),
+    -- OptimismPortal specific
+    version     UINT256 NOT NULL,
+    opaque_data VARCHAR NOT NULL,
 
-    -- Deposit information (do we need indexes on from/to?)
-	from_address     VARCHAR NOT NULL,
+    -- transaction data
+    from_address VARCHAR NOT NULL,
+    to_address   VARCHAR NOT NULL,
+    amount       UINT256 NOT NULL,
+    gas_limit    UINT256 NOT NULL,
+    data         VARCHAR NOT NULL,
+    timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
+);
+CREATE TABLE IF NOT EXISTS l2_transaction_withdrawals (
+    withdrawal_hash VARCHAR NOT NULL PRIMARY KEY,
+
+    initiated_l2_event_guid VARCHAR NOT NULL REFERENCES l2_contract_events(guid),
+
+    -- Multistep (bedrock) process of a withdrawal
+    proven_l1_event_guid    VARCHAR REFERENCES l1_contract_events(guid),
+    finalized_l1_event_guid VARCHAR REFERENCES l1_contract_events(guid),
+    succeeded               BOOLEAN,
+
+    -- L2ToL1MessagePasser specific
+    nonce UINT256 UNIQUE,
+
+    -- transaction data
+    from_address VARCHAR NOT NULL,
+    to_address   VARCHAR NOT NULL,
+    amount       UINT256 NOT NULL,
+    gas_limit    UINT256 NOT NULL,
+    data         VARCHAR NOT NULL,
+    timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
+);
+
+-- CrossDomainMessenger
+CREATE TABLE IF NOT EXISTS l1_bridge_messages(
+    nonce                   UINT256 NOT NULL PRIMARY KEY,
+    message_hash            VARCHAR NOT NULL,
+    transaction_source_hash VARCHAR NOT NULL REFERENCES l1_transaction_deposits(source_hash),
+
+    sent_message_event_guid    VARCHAR NOT NULL UNIQUE REFERENCES l1_contract_events(guid),
+    relayed_message_event_guid VARCHAR UNIQUE REFERENCES l2_contract_events(guid),
+
+    -- sent message
+    from_address VARCHAR NOT NULL,
+    to_address   VARCHAR NOT NULL,
+    amount       UINT256 NOT NULL,
+    gas_limit    UINT256 NOT NULL,
+    data         VARCHAR NOT NULL,
+    timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
+);
+CREATE TABLE IF NOT EXISTS l2_bridge_messages(
+    nonce                       UINT256 NOT NULL PRIMARY KEY,
+    message_hash                VARCHAR NOT NULL,
+    transaction_withdrawal_hash VARCHAR NOT NULL REFERENCES l2_transaction_withdrawals(withdrawal_hash),
+
+    sent_message_event_guid    VARCHAR NOT NULL UNIQUE REFERENCES l2_contract_events(guid),
+    relayed_message_event_guid VARCHAR UNIQUE REFERENCES l1_contract_events(guid),
+
+    -- sent message
+    from_address VARCHAR NOT NULL,
+    to_address   VARCHAR NOT NULL,
+    amount       UINT256 NOT NULL,
+    gas_limit    UINT256 NOT NULL,
+    data         VARCHAR NOT NULL,
+    timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
+);
+
+-- StandardBridge
+CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
+    transaction_source_hash VARCHAR PRIMARY KEY REFERENCES l1_transaction_deposits(source_hash),
 
+    -- We allow the cross_domain_messenger_nonce to be NULL-able to account
+    -- for scenarios where ETH is simply sent to the OptimismPortal contract
+    cross_domain_messenger_nonce UINT256 UNIQUE REFERENCES l1_bridge_messages(nonce),
+
+    -- Deposit information
+	from_address     VARCHAR NOT NULL,
 	to_address       VARCHAR NOT NULL,
 	l1_token_address VARCHAR NOT NULL,
 	l2_token_address VARCHAR NOT NULL,
-	amount           UINT256,
+	amount           UINT256 NOT NULL,
 	data             VARCHAR NOT NULL,
     timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
-
 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),
-    cross_domain_messenger_nonce UINT256 UNIQUE,
+    transaction_withdrawal_hash VARCHAR PRIMARY KEY REFERENCES l2_transaction_withdrawals(withdrawal_hash),
 
-    -- Multistep (bedrock) process of a withdrawal
-    withdrawal_hash      VARCHAR NOT NULL,
-    proven_l1_event_guid VARCHAR REFERENCES l1_contract_events(guid),
-
-    -- Finalization marker (legacy & bedrock)
-    finalized_l1_event_guid VARCHAR REFERENCES l1_contract_events(guid),
+    -- We allow the cross_domain_messenger_nonce to be NULL-able to account for
+    -- scenarios where ETH is simply sent to the L2ToL1MessagePasser contract
+    cross_domain_messenger_nonce UINT256 UNIQUE REFERENCES l2_bridge_messages(nonce),
 
-    -- Withdrawal information (do we need indexes on from/to?)
+    -- Withdrawal information
 	from_address     VARCHAR NOT NULL,
 	to_address       VARCHAR NOT NULL,
 	l1_token_address VARCHAR NOT NULL,
 	l2_token_address VARCHAR NOT NULL,
-	amount           UINT256,
+	amount           UINT256 NOT NULL,
 	data             VARCHAR NOT NULL,
     timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );

indexer/processor/cross_domain_messenger.go

+package processor
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+)
+
+var (
+	// Standard ABI types copied from golang ABI tests
+	Uint256Type, _ = abi.NewType("uint256", "", nil)
+	BytesType, _   = abi.NewType("bytes", "", nil)
+	AddressType, _ = abi.NewType("address", "", nil)
+
+	LegacyCrossDomainMessengerRelayMessageMethod = abi.NewMethod(
+		"relayMessage",
+		"relayMessage",
+		abi.Function,
+		"external", // mutability
+		false,      // isConst
+		true,       // payable
+		abi.Arguments{ // inputs
+			{Name: "sender", Type: AddressType},
+			{Name: "target", Type: AddressType},
+			{Name: "data", Type: BytesType},
+			{Name: "nonce", Type: Uint256Type},
+		},
+		abi.Arguments{}, // outputs
+	)
+)
+
+type CrossDomainMessengerSentMessageEvent struct {
+	*bindings.CrossDomainMessengerSentMessage
+
+	Value       *big.Int
+	MessageHash common.Hash
+	RawEvent    *database.ContractEvent
+}
+
+type CrossDomainMessengerRelayedMessageEvent struct {
+	*bindings.CrossDomainMessengerRelayedMessage
+	RawEvent *database.ContractEvent
+}
+
+func CrossDomainMessengerSentMessageEvents(events *ProcessedContractEvents) ([]CrossDomainMessengerSentMessageEvent, error) {
+	crossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	sentMessageEventAbi := crossDomainMessengerABI.Events["SentMessage"]
+	sentMessageEventExtensionAbi := crossDomainMessengerABI.Events["SentMessageExtension1"]
+
+	processedSentMessageEvents := events.eventsBySignature[sentMessageEventAbi.ID]
+	crossDomainMessageEvents := make([]CrossDomainMessengerSentMessageEvent, len(processedSentMessageEvents))
+	for i, sentMessageEvent := range processedSentMessageEvents {
+		log := events.eventLog[sentMessageEvent.GUID]
+
+		var sentMsgData bindings.CrossDomainMessengerSentMessage
+		err = UnpackLog(&sentMsgData, log, sentMessageEventAbi.Name, crossDomainMessengerABI)
+		if err != nil {
+			return nil, err
+		}
+
+		var sentMsgExtensionData bindings.CrossDomainMessengerSentMessageExtension1
+		extensionLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GUID]
+		err = UnpackLog(&sentMsgExtensionData, extensionLog, sentMessageEventExtensionAbi.Name, crossDomainMessengerABI)
+		if err != nil {
+			return nil, err
+		}
+
+		msgHash, err := CrossDomainMessageHash(crossDomainMessengerABI, &sentMsgData, sentMsgExtensionData.Value)
+		if err != nil {
+			return nil, err
+		}
+
+		crossDomainMessageEvents[i] = CrossDomainMessengerSentMessageEvent{
+			CrossDomainMessengerSentMessage: &sentMsgData,
+			Value:                           sentMsgExtensionData.Value,
+			MessageHash:                     msgHash,
+			RawEvent:                        sentMessageEvent,
+		}
+	}
+
+	return crossDomainMessageEvents, nil
+}
+
+func CrossDomainMessengerRelayedMessageEvents(events *ProcessedContractEvents) ([]CrossDomainMessengerRelayedMessageEvent, error) {
+	crossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	relayedMessageEventAbi := crossDomainMessengerABI.Events["RelayedMessage"]
+	processedRelayedMessageEvents := events.eventsBySignature[relayedMessageEventAbi.ID]
+	crossDomainMessageEvents := make([]CrossDomainMessengerRelayedMessageEvent, len(processedRelayedMessageEvents))
+	for i, relayedMessageEvent := range processedRelayedMessageEvents {
+		log := events.eventLog[relayedMessageEvent.GUID]
+
+		var relayedMsgData bindings.CrossDomainMessengerRelayedMessage
+		err = UnpackLog(&relayedMsgData, log, relayedMessageEventAbi.Name, crossDomainMessengerABI)
+		if err != nil {
+			return nil, err
+		}
+
+		crossDomainMessageEvents[i] = CrossDomainMessengerRelayedMessageEvent{&relayedMsgData, relayedMessageEvent}
+	}
+
+	return crossDomainMessageEvents, nil
+}
+
+// Replica of `Hashing.sol#hashCrossDomainMessage` solidity implementation
+func CrossDomainMessageHash(abi *abi.ABI, sentMsg *bindings.CrossDomainMessengerSentMessage, value *big.Int) (common.Hash, error) {
+	version, _ := DecodeVersionedNonce(sentMsg.MessageNonce)
+	switch version {
+	case 0:
+		// Legacy Message
+		inputBytes, err := LegacyCrossDomainMessengerRelayMessageMethod.Inputs.Pack(sentMsg.Sender, sentMsg.Target, sentMsg.Message, sentMsg.MessageNonce)
+		if err != nil {
+			return common.Hash{}, err
+		}
+		msgBytes := append(LegacyCrossDomainMessengerRelayMessageMethod.ID, inputBytes...)
+		return crypto.Keccak256Hash(msgBytes), nil
+	case 1:
+		// Current Message
+		msgBytes, err := abi.Pack("relayMessage", sentMsg.MessageNonce, sentMsg.Sender, sentMsg.Target, value, sentMsg.GasLimit, sentMsg.Message)
+		if err != nil {
+			return common.Hash{}, err
+		}
+		return crypto.Keccak256Hash(msgBytes), nil
+	}
+
+	return common.Hash{}, fmt.Errorf("unsupported cross domain messenger version: %d", version)
+}

indexer/processor/encoding.go

+package processor
+
+import (
+	"encoding/binary"
+	"math/big"
+)
+
+// DecodeVersionNonce is an re-implementation of Encoding.sol#decodeVersionedNonce.
+// If the nonce is greater than 32 bytes (solidity uint256), bytes [32:] are ignored
+func DecodeVersionedNonce(nonce *big.Int) (uint16, *big.Int) {
+	nonceBytes := nonce.Bytes()
+	nonceByteLen := len(nonceBytes)
+	if nonceByteLen < 30 {
+		// version is 0x0000
+		return 0, nonce
+	} else if nonceByteLen == 31 {
+		// version is 0x00[01..ff]
+		return uint16(nonceBytes[0]), new(big.Int).SetBytes(nonceBytes[1:])
+	} else {
+		// fully specified
+		version := binary.BigEndian.Uint16(nonceBytes[:2])
+		return version, new(big.Int).SetBytes(nonceBytes[2:])
+	}
+}

indexer/processor/l2_to_l1_message_passer.go

+package processor
+
+import (
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+)
+
+type L2ToL1MessagePasserMessagePassed struct {
+	*bindings.L2ToL1MessagePasserMessagePassed
+	RawEvent *database.ContractEvent
+}
+
+func L2ToL1MessagePasserMessagesPassed(events *ProcessedContractEvents) ([]L2ToL1MessagePasserMessagePassed, error) {
+	l2ToL1MessagePasserAbi, err := bindings.L2ToL1MessagePasserMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	eventName := "MessagePassed"
+	processedMessagePassedEvents := events.eventsBySignature[l2ToL1MessagePasserAbi.Events[eventName].ID]
+	messagesPassed := make([]L2ToL1MessagePasserMessagePassed, len(processedMessagePassedEvents))
+	for i, messagePassedEvent := range processedMessagePassedEvents {
+		log := events.eventLog[messagePassedEvent.GUID]
+
+		var messagePassed bindings.L2ToL1MessagePasserMessagePassed
+		err := UnpackLog(&messagePassed, log, eventName, l2ToL1MessagePasserAbi)
+		if err != nil {
+			return nil, err
+		}
+
+		messagesPassed[i] = L2ToL1MessagePasserMessagePassed{&messagePassed, messagePassedEvent}
+	}
+
+	return messagesPassed, nil
+}

indexer/processor/optimism_portal.go

@@ -2,19 +2,32 @@ package processor
 
 import (
 	"context"
+	"errors"
 	"math/big"
 
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
+type OptimismPortalTransactionDepositEvent struct {
+	*bindings.OptimismPortalTransactionDeposited
+	DepositTx *types.DepositTx
+	RawEvent  *database.ContractEvent
+}
+
 type OptimismPortalWithdrawalProvenEvent struct {
 	*bindings.OptimismPortalWithdrawalProven
+	RawEvent *database.ContractEvent
+}
 
+type OptimismPortalWithdrawalFinalizedEvent struct {
+	*bindings.OptimismPortalWithdrawalFinalized
 	RawEvent *database.ContractEvent
 }
 
@@ -24,6 +37,39 @@ type OptimismPortalProvenWithdrawal struct {
 	L2OutputIndex *big.Int
 }
 
+func OptimismPortalTransactionDepositEvents(events *ProcessedContractEvents) ([]OptimismPortalTransactionDepositEvent, error) {
+	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	eventName := "TransactionDeposited"
+	if optimismPortalAbi.Events[eventName].ID != derive.DepositEventABIHash {
+		return nil, errors.New("op-node deposit event abi hash & optimism portal tx deposit mismatch")
+	}
+
+	processedTxDepositedEvents := events.eventsBySignature[derive.DepositEventABIHash]
+	txDeposits := make([]OptimismPortalTransactionDepositEvent, len(processedTxDepositedEvents))
+	for i, txDepositEvent := range processedTxDepositedEvents {
+		log := events.eventLog[txDepositEvent.GUID]
+
+		depositTx, err := derive.UnmarshalDepositLogEvent(log)
+		if err != nil {
+			return nil, err
+		}
+
+		var txDeposit bindings.OptimismPortalTransactionDeposited
+		err = UnpackLog(&txDeposit, log, eventName, optimismPortalAbi)
+		if err != nil {
+			return nil, err
+		}
+
+		txDeposits[i] = OptimismPortalTransactionDepositEvent{&txDeposit, depositTx, txDepositEvent}
+	}
+
+	return txDeposits, nil
+}
+
 func OptimismPortalWithdrawalProvenEvents(events *ProcessedContractEvents) ([]OptimismPortalWithdrawalProvenEvent, error) {
 	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
 	if err != nil {
@@ -31,7 +77,6 @@ func OptimismPortalWithdrawalProvenEvents(events *ProcessedContractEvents) ([]Op
 	}
 
 	eventName := "WithdrawalProven"
-
 	processedWithdrawalProvenEvents := events.eventsBySignature[optimismPortalAbi.Events[eventName].ID]
 	provenEvents := make([]OptimismPortalWithdrawalProvenEvent, len(processedWithdrawalProvenEvents))
 	for i, provenEvent := range processedWithdrawalProvenEvents {
@@ -49,6 +94,30 @@ func OptimismPortalWithdrawalProvenEvents(events *ProcessedContractEvents) ([]Op
 	return provenEvents, nil
 }
 
+func OptimismPortalWithdrawalFinalizedEvents(events *ProcessedContractEvents) ([]OptimismPortalWithdrawalFinalizedEvent, error) {
+	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	eventName := "WithdrawalFinalized"
+	processedWithdrawalFinalizedEvents := events.eventsBySignature[optimismPortalAbi.Events[eventName].ID]
+	finalizedEvents := make([]OptimismPortalWithdrawalFinalizedEvent, len(processedWithdrawalFinalizedEvents))
+	for i, finalizedEvent := range processedWithdrawalFinalizedEvents {
+		log := events.eventLog[finalizedEvent.GUID]
+
+		var withdrawalFinalized bindings.OptimismPortalWithdrawalFinalized
+		err := UnpackLog(&withdrawalFinalized, log, eventName, optimismPortalAbi)
+		if err != nil {
+			return nil, err
+		}
+
+		finalizedEvents[i] = OptimismPortalWithdrawalFinalizedEvent{&withdrawalFinalized, finalizedEvent}
+	}
+
+	return finalizedEvents, nil
+}
+
 func OptimismPortalQueryProvenWithdrawal(ethClient *ethclient.Client, portalAddress common.Address, withdrawalHash common.Hash) (OptimismPortalProvenWithdrawal, error) {
 	var provenWithdrawal OptimismPortalProvenWithdrawal
 

op-bindings/bindings/standardbridge_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const StandardBridgeStorageLayoutJSON = "{\"storage\":[{\"astId\":1000,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":1001,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"spacer_1_0_20\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_address\"},{\"astId\":1002,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"deposits\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":1003,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_array(t_uint256)47_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)47_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[47]\",\"numberOfBytes\":\"1504\",\"base\":\"t_uint256\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const StandardBridgeStorageLayoutJSON = "{\"storage\":[{\"astId\":1000,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"_initialized\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":1001,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"_initializing\",\"offset\":1,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":1002,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"spacer_0_2_20\",\"offset\":2,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":1003,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"spacer_1_0_20\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_address\"},{\"astId\":1004,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"deposits\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":1005,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"messenger\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_contract(CrossDomainMessenger)1007\"},{\"astId\":1006,\"contract\":\"src/universal/StandardBridge.sol:StandardBridge\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_array(t_uint256)46_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)46_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[46]\",\"numberOfBytes\":\"1472\",\"base\":\"t_uint256\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_contract(CrossDomainMessenger)1007\":{\"encoding\":\"inplace\",\"label\":\"contract CrossDomainMessenger\",\"numberOfBytes\":\"20\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
 
 var StandardBridgeStorageLayout = new(solc.StorageLayout)
 

op-bindings/solc/types.go

@@ -64,6 +64,15 @@ func (s *StorageLayout) GetStorageLayoutEntry(name string) (StorageLayoutEntry,
 	return StorageLayoutEntry{}, fmt.Errorf("%s not found", name)
 }
 
+// GetStorageLayoutType returns the StorageLayoutType where the label matches
+// the provided name.
+func (s *StorageLayout) GetStorageLayoutType(name string) (StorageLayoutType, error) {
+	if ty, ok := s.Types[name]; ok {
+		return ty, nil
+	}
+	return StorageLayoutType{}, fmt.Errorf("%s not found", name)
+}
+
 type StorageLayoutEntry struct {
 	AstId    uint   `json:"astId"`
 	Contract string `json:"contract"`

op-chain-ops/cmd/check-l2/main.go

@@ -36,16 +36,16 @@ func main() {
 		Usage: "Check that an OP Stack L2 has been configured correctly",
 		Flags: []cli.Flag{
 			&cli.StringFlag{
-				Name:     "l1-rpc-url",
-				Required: true,
-				Usage:    "L1 RPC URL",
-				EnvVars:  []string{"L1_RPC_URL"},
+				Name:    "l1-rpc-url",
+				Value:   "http://127.0.0.1:8545",
+				Usage:   "L1 RPC URL",
+				EnvVars: []string{"L1_RPC_URL"},
 			},
 			&cli.StringFlag{
-				Name:     "l2-rpc-url",
-				Required: true,
-				Usage:    "L2 RPC URL",
-				EnvVars:  []string{"L2_RPC_URL"},
+				Name:    "l2-rpc-url",
+				Value:   "http://127.0.0.1:9545",
+				Usage:   "L2 RPC URL",
+				EnvVars: []string{"L2_RPC_URL"},
 			},
 		},
 		Action: entrypoint,
@@ -603,11 +603,17 @@ func checkL2StandardBridge(addr common.Address, client *ethclient.Client) error
 	if messenger != predeploys.L2CrossDomainMessengerAddr {
 		return fmt.Errorf("L2StandardBridge MESSENGER should be %s, got %s", predeploys.L2CrossDomainMessengerAddr, messenger)
 	}
-
 	version, err := contract.Version(&bind.CallOpts{})
 	if err != nil {
 		return err
 	}
+
+	initialized, err := getInitialized("L2StandardBridge", addr, client)
+	if err != nil {
+		return err
+	}
+	log.Info("L2StandardBridge", "_initialized", initialized)
+
 	log.Info("L2StandardBridge version", "version", version)
 	return nil
 }
@@ -714,6 +720,13 @@ func checkL2CrossDomainMessenger(addr common.Address, client *ethclient.Client)
 	if err != nil {
 		return err
 	}
+
+	initialized, err := getInitialized("L2CrossDomainMessenger", addr, client)
+	if err != nil {
+		return err
+	}
+	log.Info("L2CrossDomainMessenger", "_initialized", initialized)
+
 	log.Info("L2CrossDomainMessenger version", "version", version)
 	return nil
 }
@@ -805,3 +818,36 @@ func getEIP1967ImplementationAddress(client *ethclient.Client, addr common.Addre
 	impl := common.BytesToAddress(slot)
 	return impl, nil
 }
+
+// getInitialized will get the initialized value in storage of a contract.
+// This is an incrementing number that starts at 1 and increments each time that
+// the contract is upgraded.
+func getInitialized(name string, addr common.Address, client *ethclient.Client) (*big.Int, error) {
+	layout, err := bindings.GetStorageLayout(name)
+	if err != nil {
+		return nil, err
+	}
+	entry, err := layout.GetStorageLayoutEntry("_initialized")
+	if err != nil {
+		return nil, err
+	}
+	typ, err := layout.GetStorageLayoutType(entry.Type)
+	if err != nil {
+		return nil, err
+	}
+	slot := common.BigToHash(big.NewInt(int64(entry.Slot)))
+	value, err := client.StorageAt(context.Background(), addr, slot, nil)
+	if err != nil {
+		return nil, err
+	}
+	if entry.Offset+typ.NumberOfBytes > uint(len(value)) {
+		return nil, fmt.Errorf("value length is too short")
+	}
+	// Swap the endianness
+	slice := common.CopyBytes(value)
+	for i, j := 0, len(slice)-1; i < j; i, j = i+1, j-1 {
+		slice[i], slice[j] = slice[j], slice[i]
+	}
+	initialized := new(big.Int).SetBytes(slice[entry.Offset : entry.Offset+typ.NumberOfBytes])
+	return initialized, nil
+}

op-chain-ops/genesis/config.go

@@ -656,6 +656,11 @@ func NewL2StorageConfig(config *DeployConfig, block *types.Block) (state.Storage
 		"xDomainMsgSender": "0x000000000000000000000000000000000000dEaD",
 		"msgNonce":         0,
 	}
+	storage["L2StandardBridge"] = state.StorageValues{
+		"_initialized":  2,
+		"_initializing": false,
+		"messenger":     predeploys.L2CrossDomainMessengerAddr,
+	}
 	storage["L1Block"] = state.StorageValues{
 		"number":         block.Number(),
 		"timestamp":      block.Time(),
@@ -685,6 +690,11 @@ func NewL2StorageConfig(config *DeployConfig, block *types.Block) (state.Storage
 	storage["ProxyAdmin"] = state.StorageValues{
 		"_owner": config.ProxyAdminOwner,
 	}
+	storage["L2ERC721Bridge"] = state.StorageValues{
+		"messenger":     predeploys.L2CrossDomainMessengerAddr,
+		"_initialized":  2,
+		"_initializing": false,
+	}
 	return storage, nil
 }
 

op-chain-ops/immutables/immutables.go

@@ -131,7 +131,6 @@ func BuildOptimism(immutable ImmutableConfig) (DeploymentResults, error) {
 		{
 			Name: "L2ERC721Bridge",
 			Args: []interface{}{
-				predeploys.L2CrossDomainMessengerAddr,
 				immutable["L2ERC721Bridge"]["otherBridge"],
 			},
 		},
@@ -225,16 +224,11 @@ func l2Deployer(backend *backends.SimulatedBackend, opts *bind.TransactOpts, dep
 	case "L1BlockNumber":
 		_, tx, _, err = bindings.DeployL1BlockNumber(opts, backend)
 	case "L2ERC721Bridge":
-		// TODO(tynes): messenger should be hardcoded in the contract
-		messenger, ok := deployment.Args[0].(common.Address)
-		if !ok {
-			return nil, fmt.Errorf("invalid type for messenger")
-		}
-		otherBridge, ok := deployment.Args[1].(common.Address)
+		otherBridge, ok := deployment.Args[0].(common.Address)
 		if !ok {
 			return nil, fmt.Errorf("invalid type for otherBridge")
 		}
-		_, tx, _, err = bindings.DeployL2ERC721Bridge(opts, backend, messenger, otherBridge)
+		_, tx, _, err = bindings.DeployL2ERC721Bridge(opts, backend, otherBridge)
 	case "OptimismMintableERC721Factory":
 		bridge, ok := deployment.Args[0].(common.Address)
 		if !ok {

op-chain-ops/state/memory_db_test.go

@@ -52,7 +52,11 @@ func TestCode(t *testing.T) {
 		db.SetCode(addr, code)
 
 		post := db.GetCode(addr)
-		require.Equal(t, post, code)
+		if len(code) == 0 {
+			require.Nil(t, post)
+		} else {
+			require.Equal(t, post, code)
+		}
 
 		size := db.GetCodeSize(addr)
 		require.Equal(t, size, len(code))

packages/contracts-bedrock/layout-lock.json

@@ -94,9 +94,9 @@
     }
   },
   "L1StandardBridge": {
-    "spacer_0_0_20": {
+    "spacer_0_2_20": {
       "slot": 0,
-      "offset": 0,
+      "offset": 2,
       "length": 20
     },
     "spacer_1_0_20": {

packages/contracts-bedrock/src/L2/L2StandardBridge.sol

@@ -5,6 +5,7 @@ import { Predeploys } from "../libraries/Predeploys.sol";
 import { StandardBridge } from "../universal/StandardBridge.sol";
 import { Semver } from "../universal/Semver.sol";
 import { OptimismMintableERC20 } from "../universal/OptimismMintableERC20.sol";
+import { CrossDomainMessenger } from "../universal/CrossDomainMessenger.sol";
 
 /// @custom:proxied
 /// @custom:predeploy 0x4200000000000000000000000000000000000010
@@ -50,13 +51,19 @@ contract L2StandardBridge is StandardBridge, Semver {
         bytes extraData
     );
 
-    /// @custom:semver 1.1.1
+    /// @custom:semver 1.2.0
     /// @notice Constructs the L2StandardBridge contract.
     /// @param _otherBridge Address of the L1StandardBridge.
-    constructor(address payable _otherBridge)
-        Semver(1, 1, 1)
-        StandardBridge(payable(Predeploys.L2_CROSS_DOMAIN_MESSENGER), _otherBridge)
-    {}
+    constructor(StandardBridge _otherBridge) Semver(1, 2, 0) StandardBridge(_otherBridge) {
+        initialize();
+    }
+
+    /// @notice Initializer
+    function initialize() public reinitializer(2) {
+        __StandardBridge_init({
+            _messenger: CrossDomainMessenger(Predeploys.L2_CROSS_DOMAIN_MESSENGER)
+        });
+    }
 
     /// @notice Allows EOAs to bridge ETH by sending directly to the bridge.
     receive() external payable override onlyEOA {

packages/contracts-bedrock/src/cannon/MIPS.sol

@@ -53,9 +53,14 @@ contract MIPS {
     uint32 constant EBADF = 0x9;
     uint32 constant EINVAL = 0x16;
 
-    /// @notice The pre-image oracle.
+    /// @notice The preimage oracle contract.
     IPreimageOracle public oracle;
 
+    /// @param _oracle The address of the preimage oracle contract.
+    constructor(IPreimageOracle _oracle) {
+        oracle = _oracle;
+    }
+
     /// @notice Extends the value leftwards with its most significant bit (sign extension).
     function SE(uint32 _dat, uint32 _idx) internal pure returns (uint32) {
         unchecked {

packages/contracts-bedrock/test/L1StandardBridge.t.sol

@@ -35,6 +35,13 @@ contract L1StandardBridge_Initialize_Test is Bridge_Initializer {
         assertEq(address(L1Bridge.OTHER_BRIDGE()), Predeploys.L2_STANDARD_BRIDGE);
         assertEq(address(L2Bridge), Predeploys.L2_STANDARD_BRIDGE);
     }
+
+    function test_initialize_fix_succeeds() external {
+        bytes32 slot0 = vm.load(address(L1Bridge), bytes32(uint256(0)));
+        // The first storage slot should only have its first byte set to 0x02.
+        // This covers the `clearLegacySlot` fix.
+        assertEq(slot0, bytes32(uint256(2)));
+    }
 }
 
 contract L1StandardBridge_Initialize_TestFail is Bridge_Initializer {}

packages/contracts-bedrock/test/MIPS.t.sol

@@ -11,7 +11,7 @@ contract MIPS_Test is Test {
 
     function setUp() public {
         oracle = new PreimageOracle();
-        mips = new MIPS();
+        mips = new MIPS(oracle);
         vm.store(address(mips), 0x0, bytes32(abi.encode(address(oracle))));
         vm.label(address(oracle), "PreimageOracle");
         vm.label(address(mips), "MIPS");

packages/contracts-bedrock/test/StandardBridge.t.sol

@@ -14,7 +14,7 @@ import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 ///         internal functions so they can be more easily tested directly.
 contract StandardBridgeTester is StandardBridge {
     constructor(address payable _messenger, address payable _otherBridge)
-        StandardBridge(_messenger, _otherBridge)
+        StandardBridge(StandardBridge(_otherBridge))
     {}
 
     function isOptimismMintableERC20(address _token) external view returns (bool) {

packages/contracts-ts/package.json

@@ -10,8 +10,8 @@
   },
   "homepage": "https://optimism.io",
   "type": "module",
-  "main": "dist/constants.js",
-  "module": "dist/constants.mjs",
+  "main": "dist/constants.cjs",
+  "module": "dist/constants.js",
   "types": "src/constants.ts",
   "exports": {
     ".": {

packages/fee-estimation/package.json

@@ -10,8 +10,16 @@
   },
   "homepage": "https://optimism.io",
   "type": "module",
-  "main": "dist/estimateFees.js",
-  "module": "dist/estimateFees.mjs",
+  "main": "dist/estimateFees.cjs",
+  "module": "dist/estimateFees.js",
+  "exports": {
+    ".": {
+      "import": "./dist/estimateFees.js",
+      "require": "./dist/estimateFees.cjs",
+      "default": "./dist/estimateFees.js",
+      "types": "./src/estimateFees.ts"
+    }
+  },
   "types": "src/estimateFees.ts",
   "files": [
     "dist/",