Merge branch 'develop' into refcell/abigen-ci

cannon/cmd/witness.go

+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/urfave/cli/v2"
+)
+
+var (
+	WitnessInputFlag = &cli.PathFlag{
+		Name:      "input",
+		Usage:     "path of input JSON state.",
+		TakesFile: true,
+		Required:  true,
+	}
+	WitnessOutputFlag = &cli.PathFlag{
+		Name:      "output",
+		Usage:     "path to write binary witness.",
+		TakesFile: true,
+	}
+)
+
+func Witness(ctx *cli.Context) error {
+	input := ctx.Path(WitnessInputFlag.Name)
+	output := ctx.Path(WitnessOutputFlag.Name)
+	state, err := loadJSON[mipsevm.State](input)
+	if err != nil {
+		return fmt.Errorf("invalid input state (%v): %w", input, err)
+	}
+	witness := state.EncodeWitness()
+	h := crypto.Keccak256Hash(witness)
+	if output != "" {
+		if err := os.WriteFile(output, witness, 0755); err != nil {
+			return fmt.Errorf("writing output to %v: %w", output, err)
+		}
+	}
+	fmt.Println(h.Hex())
+	return nil
+}
+
+var WitnessCommand = &cli.Command{
+	Name:        "witness",
+	Usage:       "Convert a Cannon JSON state into a binary witness",
+	Description: "Convert a Cannon JSON state into a binary witness. The hash of the witness is written to stdout",
+	Action:      Witness,
+	Flags: []cli.Flag{
+		WitnessInputFlag,
+		WitnessOutputFlag,
+	},
+}

cannon/main.go

@@ -20,6 +20,7 @@ func main() {
 	app.Description = "MIPS Fault Proof tool"
 	app.Commands = []*cli.Command{
 		cmd.LoadELFCommand,
+		cmd.WitnessCommand,
 		cmd.RunCommand,
 	}
 	ctx, cancel := context.WithCancel(context.Background())

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/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))

op-challenger/.gitignore

 bin
+.fault-game-address

op-challenger/Makefile

@@ -19,8 +19,23 @@ test:
 lint:
 	golangci-lint run -E goimports,sqlclosecheck,bodyclose,asciicheck,misspell,errorlint -e "errors.As" -e "errors.Is"
 
+visualize:
+	./scripts/visualize.sh
+
+alphabet:
+	./scripts/alphabet/init_game.sh
+	make alphabet-actors
+
+alphabet-actors:
+	@./scripts/parallel.sh \
+	./scripts/alphabet/mallory.sh 'mallory' \
+	./scripts/alphabet/charlie.sh 'charlie'
+
 .PHONY: \
 	clean \
 	op-challenger \
 	test \
-	lint
+	lint \
+	visualize \
+	alphabet \
+	alphabet-actors

op-challenger/config/config_test.go

@@ -14,6 +14,7 @@ var (
 	validAlphabetTrace         = "abcdefgh"
 	validCannonBin             = "./bin/cannon"
 	validCannonOpProgramBin    = "./bin/op-program"
+	validCannonNetwork         = "mainnet"
 	validCannonAbsolutPreState = "pre.json"
 	validCannonDatadir         = "/tmp/cannon"
 	validCannonL2              = "http://localhost:9545"
@@ -32,6 +33,7 @@ func validConfig(traceType TraceType) Config {
 		cfg.CannonAbsolutePreState = validCannonAbsolutPreState
 		cfg.CannonDatadir = validCannonDatadir
 		cfg.CannonL2 = validCannonL2
+		cfg.CannonNetwork = validCannonNetwork
 	}
 	return cfg
 }
@@ -110,3 +112,41 @@ func TestCannonSnapshotFreq(t *testing.T) {
 		require.ErrorIs(t, cfg.Check(), ErrMissingCannonSnapshotFreq)
 	})
 }
+
+func TestCannonNetworkOrRollupConfigRequired(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = ""
+	cfg.CannonRollupConfigPath = ""
+	cfg.CannonL2GenesisPath = "genesis.json"
+	require.ErrorIs(t, cfg.Check(), ErrMissingCannonRollupConfig)
+}
+
+func TestCannonNetworkOrL2GenesisRequired(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = ""
+	cfg.CannonRollupConfigPath = "foo.json"
+	cfg.CannonL2GenesisPath = ""
+	require.ErrorIs(t, cfg.Check(), ErrMissingCannonL2Genesis)
+}
+
+func TestMustNotSpecifyNetworkAndRollup(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = validCannonNetwork
+	cfg.CannonRollupConfigPath = "foo.json"
+	cfg.CannonL2GenesisPath = ""
+	require.ErrorIs(t, cfg.Check(), ErrCannonNetworkAndRollupConfig)
+}
+
+func TestMustNotSpecifyNetworkAndL2Genesis(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = validCannonNetwork
+	cfg.CannonRollupConfigPath = ""
+	cfg.CannonL2GenesisPath = "foo.json"
+	require.ErrorIs(t, cfg.Check(), ErrCannonNetworkAndL2Genesis)
+}
+
+func TestNetworkMustBeValid(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = "unknown"
+	require.ErrorIs(t, cfg.Check(), ErrCannonNetworkUnknown)
+}

op-challenger/fault/cannon/cannon_state.go

+package cannon
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
+)
+
+func parseState(path string) (*mipsevm.State, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("cannot open state file (%v): %w", path, err)
+	}
+	defer file.Close()
+	var state mipsevm.State
+	err = json.NewDecoder(file).Decode(&state)
+	if err != nil {
+		return nil, fmt.Errorf("invalid mipsevm state (%v): %w", path, err)
+	}
+	return &state, nil
+}

op-challenger/init_game.sh

-#!/bin/bash
-set -euo pipefail
-
-DIR=$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)
-cd "$DIR"
-
-make
-
-cd ..
-
-make devnet-clean
-make devnet-up-deploy
-
-DEVNET_SPONSOR="ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
-DISPUTE_GAME_PROXY="0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e"
-
-CHARLIE_ADDRESS="0xF45B7537828CB2fffBC69996B054c2Aaf36DC778"
-CHARLIE_KEY="74feb147d72bfae943e6b4e483410933d9e447d5dc47d52432dcc2c1454dabb7"
-
-MALLORY_ADDRESS="0x4641c704a6c743f73ee1f36C7568Fbf4b80681e4"
-MALLORY_KEY="28d7045146193f5f4eeb151c4843544b1b0d30a7ac1680c845a416fac65a7715"
-
-echo "----------------------------------------------------------------"
-echo " - Fetching balance of the sponsor"
-echo " - Balance: $(cast balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)"
-echo "----------------------------------------------------------------"
-
-echo "Funding Charlie"
-cast send $CHARLIE_ADDRESS --value 5ether --private-key $DEVNET_SPONSOR
-
-echo "Funding Mallory"
-cast send $MALLORY_ADDRESS --value 5ether --private-key $DEVNET_SPONSOR
-
-# Fault game type = 0
-GAME_TYPE=0
-# Root claim commits to the entire trace.
-# Alphabet game claim construction: keccak256(abi.encode(trace_index, trace[trace_index]))
-ROOT_CLAIM=$(cast keccak $(cast abi-encode "f(uint256,uint256)" 15 122))
-# Extra data is a dynamic `bytes` type that contains the L2 Block Number of the output proposal that the root claim disagrees with
-# Doesn't matter right now since we're not deleting outputs, so just set it to 1
-EXTRA_DATA=$(cast to-bytes32 1)
-
-echo "Initializing the game"
-cast call --private-key $MALLORY_KEY $DISPUTE_GAME_PROXY "create(uint8,bytes32,bytes)" $GAME_TYPE $ROOT_CLAIM $EXTRA_DATA
-cast send --private-key $MALLORY_KEY $DISPUTE_GAME_PROXY "create(uint8,bytes32,bytes)" $GAME_TYPE $ROOT_CLAIM $EXTRA_DATA

op-challenger/scripts/parallel.sh

+#!/bin/bash
+
+# set -x
+
+trap killgroup SIGINT
+
+killgroup(){
+  echo killing...
+  kill 0
+}
+
+$1 | sed  "s/^/[$2] /" &
+$3 | sed  "s/^/[$4] /" &
+wait

op-e2e/e2eutils/disputegame/game_helper.go

@@ -33,7 +33,7 @@ func (g *FaultGameHelper) GameDuration(ctx context.Context) time.Duration {
 }
 
 func (g *FaultGameHelper) WaitForClaimCount(ctx context.Context, count int64) {
-	ctx, cancel := context.WithTimeout(ctx, time.Minute)
+	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
 	defer cancel()
 	err := utils.WaitFor(ctx, time.Second, func() (bool, error) {
 		actual, err := g.game.ClaimDataLen(&bind.CallOpts{Context: ctx})

op-e2e/system_tob_test.go

@@ -409,7 +409,7 @@ func TestMixedWithdrawalValidity(t *testing.T) {
 			l2Verif := sys.Clients["verifier"]
 			require.NoError(t, err)
 
-			systemConfig, err := bindings.NewSystemConfigCaller(cfg.L1Deployments.SystemConfig, l1Client)
+			systemConfig, err := bindings.NewSystemConfigCaller(cfg.L1Deployments.SystemConfigProxy, l1Client)
 			require.NoError(t, err)
 			unsafeBlockSigner, err := systemConfig.UnsafeBlockSigner(nil)
 			require.NoError(t, err)

packages/contracts-bedrock/deploy-config/devnetL1.json

@@ -45,5 +45,6 @@
   "l2GenesisRegolithTimeOffset": "0x0",
   "faultGameAbsolutePrestate": "0x41c7ae758795765c6664a5d39bf63841c71ff191e9189522bad8ebff5d4eca98",
   "faultGameMaxDepth": 4,
-  "faultGameMaxDuration": 300
+  "faultGameMaxDuration": 300,
+  "systemConfigStartBlock": 0
 }

packages/contracts-bedrock/invariant-docs/SystemConfig.md

 # `SystemConfig` Invariants
 
 ## The gas limit of the `SystemConfig` contract can never be lower than the hard-coded lower bound.
-**Test:** [`SystemConfig.t.sol#L44`](../test/invariants/SystemConfig.t.sol#L44)
+**Test:** [`SystemConfig.t.sol#L65`](../test/invariants/SystemConfig.t.sol#L65)
 

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/package.json

@@ -44,6 +44,6 @@
     "solhint": "^3.4.1",
     "solhint-plugin-prettier": "^0.0.5",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.3"
+    "typescript": "^5.1.6"
   }
 }

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/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/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-bedrock/test/invariants/SystemConfig.t.sol

@@ -3,24 +3,45 @@ pragma solidity 0.8.15;
 
 import { Test } from "forge-std/Test.sol";
 import { SystemConfig } from "../../src/L1/SystemConfig.sol";
+import { Proxy } from "../../src/universal/Proxy.sol";
 import { ResourceMetering } from "../../src/L1/ResourceMetering.sol";
 import { Constants } from "../../src/libraries/Constants.sol";
 
 contract SystemConfig_GasLimitLowerBound_Invariant is Test {
     SystemConfig public config;
 
-    function setUp() public {
-        ResourceMetering.ResourceConfig memory cfg = Constants.DEFAULT_RESOURCE_CONFIG();
+    function setUp() external {
+        Proxy proxy = new Proxy(msg.sender);
+        SystemConfig configImpl = new SystemConfig();
 
-        config = new SystemConfig({
-            _owner: address(0xbeef),
-            _overhead: 2100,
-            _scalar: 1000000,
-            _batcherHash: bytes32(hex"abcd"),
-            _gasLimit: 30_000_000,
-            _unsafeBlockSigner: address(1),
-            _config: cfg
-        });
+        vm.prank(msg.sender);
+        proxy.upgradeToAndCall(
+            address(configImpl),
+            abi.encodeCall(
+                configImpl.initialize,
+                (
+                    address(0xbeef),                      // owner
+                    2100,                                 // overhead
+                    1000000,                              // scalar
+                    bytes32(hex"abcd"),                   // batcher hash
+                    30_000_000,                           // gas limit
+                    address(1),                           // unsafe block signer
+                    Constants.DEFAULT_RESOURCE_CONFIG(),  // resource config
+                    0,                                    //_startBlock
+                    address(0),                           // _batchInbox
+                    SystemConfig.Addresses({              // _addrs
+                        l1CrossDomainMessenger: address(0),
+                        l1ERC721Bridge: address(0),
+                        l1StandardBridge: address(0),
+                        l2OutputOracle: address(0),
+                        optimismPortal: address(0),
+                        optimismMintableERC20Factory: address(0)
+                    })
+                )
+            )
+        );
+
+        config = SystemConfig(address(proxy));
 
         // Set the target contract to the `config`
         targetContract(address(config));

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": {
     ".": {
@@ -51,7 +51,7 @@
     "@testing-library/jest-dom": "^5.17.0",
     "@testing-library/react-hooks": "^8.0.1",
     "@types/glob": "^8.1.0",
-    "@vitest/coverage-istanbul": "^0.33.0",
+    "@vitest/coverage-istanbul": "^0.34.1",
     "@wagmi/cli": "^1.3.0",
     "@wagmi/core": "^1.3.8",
     "abitype": "^0.9.3",

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/",
@@ -29,7 +37,7 @@
     "@eth-optimism/contracts-ts": "workspace:^",
     "@testing-library/jest-dom": "^5.17.0",
     "@testing-library/react-hooks": "^8.0.1",
-    "@vitest/coverage-istanbul": "^0.33.0",
+    "@vitest/coverage-istanbul": "^0.34.1",
     "abitype": "^0.9.3",
     "isomorphic-fetch": "^3.0.0",
     "jest-dom": "link:@types/@testing-library/jest-dom",

specs/challenger.md

@@ -48,7 +48,7 @@ to each of the different game types. For specification of dispute game types, se
 
 ### `GameType.FAULT`
 
-> **Warning**  
+> **Warning**
 > The `FAULT` game type is not yet implemented. In the first iteration of Optimism's decentralization effort,
 > challengers will respond to `ATTESTATION` games only.
 
@@ -59,7 +59,7 @@ to each of the different game types. For specification of dispute game types, se
 
 **Events and Responses**
 
-- [`L2OutputOracle.OutputProposed`](../packages/contracts-bedrock/contracts/L1/L2OutputOracle.sol#L57-70)
+- [`L2OutputOracle.OutputProposed`](../packages/contracts-bedrock/src/L1/L2OutputOracle.sol#L57-70)
   The `L2OutputOracle` contract emits this event when a new output is proposed on the data availability
   layer. Each time an output is proposed, the Challenger should check to see if the output is equal
   the output given by the `optimism_outputAtBlock` endpoint of their `rollup-node`.
@@ -85,7 +85,7 @@ A full diagram and lifecycle of the Challenger's role in the `ATTESTATION` game
 
 **TODO**
 
-> **Warning**  
+> **Warning**
 > The `VALIDITY` game type is not yet implemented. In the first iteration of Optimism's decentralization effort,
 > challengers will respond to `ATTESTATION` games only. A validity proof based dispute game is a possibility,
 > but fault proof based dispute games will be the primary focus of the team in the near future.

specs/deposits.md

@@ -306,7 +306,7 @@ The contract has the following solidity interface, and can be interacted with ac
 
 A reference implementation of the L1 Attributes predeploy contract can be found in [L1Block.sol].
 
-[L1Block.sol]: ../packages/contracts-bedrock/contracts/L2/L1Block.sol
+[L1Block.sol]: ../packages/contracts-bedrock/src/L2/L1Block.sol
 
 After running `pnpm build` in the `packages/contracts` directory, the bytecode to add to the genesis
 file will be located in the `deployedBytecode` field of the build artifacts file at

specs/predeploys.md

@@ -70,7 +70,7 @@ or `Bedrock`. Deprecated contracts should not be used.
 
 ## LegacyMessagePasser
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/legacy/LegacyMessagePasser.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/legacy/LegacyMessagePasser.sol)
 
 Address: `0x4200000000000000000000000000000000000000`
 
@@ -92,7 +92,7 @@ finalized.
 
 ## L2ToL1MessagePasser
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L2/L2ToL1MessagePasser.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2ToL1MessagePasser.sol)
 
 Address: `0x4200000000000000000000000000000000000016`
 
@@ -106,7 +106,7 @@ permissionlessly removed from the L2 supply by calling the `burn()` function.
 
 ## DeployerWhitelist
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/legacy/DeployerWhitelist.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/legacy/DeployerWhitelist.sol)
 
 Address: `0x4200000000000000000000000000000000000002`
 
@@ -125,7 +125,7 @@ This contract is deprecated and its usage should be avoided.
 
 ## LegacyERC20ETH
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/legacy/LegacyERC20ETH.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/legacy/LegacyERC20ETH.sol)
 
 Address: `0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000`
 
@@ -141,7 +141,7 @@ This contract is deprecated and its usage should be avoided.
 
 ## WETH9
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/vendor/WETH9.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/vendor/WETH9.sol)
 
 Address: `0x4200000000000000000000000000000000000006`
 
@@ -151,7 +151,7 @@ deterministic address across Optimism based networks.
 
 ## L2CrossDomainMessenger
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L2/L2CrossDomainMessenger.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2CrossDomainMessenger.sol)
 
 Address: `0x4200000000000000000000000000000000000007`
 
@@ -170,7 +170,7 @@ domain through the remote domain's `relayMessage` function.
 
 ## L2StandardBridge
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L2/L2StandardBridge.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2StandardBridge.sol)
 
 Address: `0x4200000000000000000000000000000000000010`
 
@@ -197,7 +197,7 @@ withdrawn to L1.
 
 ## L1BlockNumber
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/legacy/L1BlockNumber.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/legacy/L1BlockNumber.sol)
 
 Address: `0x4200000000000000000000000000000000000013`
 
@@ -210,7 +210,7 @@ L1 on L2.
 
 ## GasPriceOracle
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L2/GasPriceOracle.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/GasPriceOracle.sol)
 
 Address: `0x420000000000000000000000000000000000000F`
 
@@ -240,7 +240,7 @@ has been hardcoded to 6.
 
 ## L1Block
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L2/L1Block.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L1Block.sol)
 
 Address: `0x4200000000000000000000000000000000000015`
 
@@ -251,7 +251,7 @@ maintaining L1 context in L2. This allows for L1 state to be accessed in L2.
 
 ## ProxyAdmin
 
-[ProxyAdmin](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/universal/ProxyAdmin.sol)
+[ProxyAdmin](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/universal/ProxyAdmin.sol)
 Address: `0x4200000000000000000000000000000000000018`
 
 The `ProxyAdmin` is the owner of all of the proxy contracts set at the
@@ -260,7 +260,7 @@ have the ability to upgrade any of the other predeploy contracts.
 
 ## SequencerFeeVault
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L2/SequencerFeeVault.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/SequencerFeeVault.sol)
 
 Address: `0x4200000000000000000000000000000000000011`
 
@@ -273,7 +273,7 @@ upgraded by changing its proxy's implementation key.
 
 ## OptimismMintableERC20Factory
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/universal/OptimismMintableERC20Factory.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/universal/OptimismMintableERC20Factory.sol)
 
 Address: `0x4200000000000000000000000000000000000012`
 
@@ -286,7 +286,7 @@ and burn tokens, depending on if the user is depositing from L1 to L2 or withdra
 
 ## OptimismMintableERC721Factory
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/universal/OptimismMintableERC721Factory.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/universal/OptimismMintableERC721Factory.sol)
 
 Address: `0x4200000000000000000000000000000000000017`
 
@@ -295,7 +295,7 @@ depositing native L1 NFTs into.
 
 ## BaseFeeVault
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L2/BaseFeeVault.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/BaseFeeVault.sol)
 
 Address: `0x4200000000000000000000000000000000000019`
 
@@ -306,7 +306,7 @@ L1.
 
 ## L1FeeVault
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/L2/L1FeeVault.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L1FeeVault.sol)
 
 Address: `0x420000000000000000000000000000000000001a`
 
@@ -316,7 +316,7 @@ withdrawn to an immutable address on L1.
 
 ## SchemaRegistry
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/EAS/SchemaRegistry.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/EAS/SchemaRegistry.sol)
 
 Address: `0x4200000000000000000000000000000000000020`
 
@@ -325,7 +325,7 @@ protocol.
 
 ## EAS
 
-[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/contracts/EAS/EAS.sol)
+[Implementation](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/EAS/EAS.sol)
 
 Address: `0x4200000000000000000000000000000000000021`