Merge pull request #7119 from ethereum-optimism/indexer.legacy.blocks

feat(indexer): bridge process pre-bedrock blocks

indexer/bigint/bigint.go

@@ -37,7 +37,6 @@ func Grouped(start, end *big.Int, size uint64) []Range {
 	if end.Cmp(start) < 0 || size == 0 {
 		return nil
 	}
-
 	bigMaxDiff := big.NewInt(int64(size - 1))
 
 	groups := []Range{}

indexer/config/config.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/BurntSushi/toml"
 	"github.com/ethereum/go-ethereum/common"
-	geth_log "github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/log"
 )
 
 const (
@@ -34,6 +34,9 @@ type L1Contracts struct {
 	L1CrossDomainMessengerProxy common.Address `toml:"l1-cross-domain-messenger"`
 	L1StandardBridgeProxy       common.Address `toml:"l1-standard-bridge"`
 
+	// Pre-Bedrock Legacy Contracts
+	LegacyCanonicalTransactionChain common.Address `toml:"l1-canonical-transaction-chain"`
+
 	// Some more contracts -- L1ERC721Bridge, ProxyAdmin, SystemConfig, etc
 	// Ignore the auxiliary contracts?
 
@@ -69,6 +72,10 @@ type ChainConfig struct {
 	L1Contracts      L1Contracts `toml:"l1-contracts"`
 	L1StartingHeight uint        `toml:"l1-starting-height"`
 
+	// Bedrock starting heights only applicable for OP-Mainnet & OP-Goerli
+	L1BedrockStartingHeight uint `toml:"-"`
+	L2BedrockStartingHeight uint `toml:"-"`
+
 	// These configuration options will be removed once
 	// native reorg handling is implemented
 	L1ConfirmationDepth uint `toml:"l1-confirmation-depth"`
@@ -103,8 +110,8 @@ type ServerConfig struct {
 }
 
 // LoadConfig loads the `indexer.toml` config file from a given path
-func LoadConfig(logger geth_log.Logger, path string) (Config, error) {
-	logger.Debug("loading config", "path", path)
+func LoadConfig(log log.Logger, path string) (Config, error) {
+	log.Debug("loading config", "path", path)
 
 	var conf Config
 	data, err := os.ReadFile(path)
@@ -113,9 +120,9 @@ func LoadConfig(logger geth_log.Logger, path string) (Config, error) {
 	}
 
 	data = []byte(os.ExpandEnv(string(data)))
-	logger.Debug("parsed config file", "data", string(data))
+	log.Debug("parsed config file", "data", string(data))
 	if _, err := toml.Decode(string(data), &conf); err != nil {
-		logger.Info("failed to decode config file", "err", err)
+		log.Info("failed to decode config file", "err", err)
 		return conf, err
 	}
 
@@ -124,31 +131,34 @@ func LoadConfig(logger geth_log.Logger, path string) (Config, error) {
 		if !ok {
 			return conf, fmt.Errorf("unknown preset: %d", conf.Chain.Preset)
 		}
+
 		conf.Chain.L1Contracts = knownPreset.L1Contracts
 		conf.Chain.L1StartingHeight = knownPreset.L1StartingHeight
+		conf.Chain.L1BedrockStartingHeight = knownPreset.L1BedrockStartingHeight
+		conf.Chain.L2BedrockStartingHeight = knownPreset.L1BedrockStartingHeight
 	}
 
 	// Set polling defaults if not set
 	if conf.Chain.L1PollingInterval == 0 {
-		logger.Info("setting default L1 polling interval", "interval", defaultLoopInterval)
+		log.Info("setting default L1 polling interval", "interval", defaultLoopInterval)
 		conf.Chain.L1PollingInterval = defaultLoopInterval
 	}
 
 	if conf.Chain.L2PollingInterval == 0 {
-		logger.Info("setting default L2 polling interval", "interval", defaultLoopInterval)
+		log.Info("setting default L2 polling interval", "interval", defaultLoopInterval)
 		conf.Chain.L2PollingInterval = defaultLoopInterval
 	}
 
 	if conf.Chain.L1HeaderBufferSize == 0 {
-		logger.Info("setting default L1 header buffer", "size", defaultHeaderBufferSize)
+		log.Info("setting default L1 header buffer", "size", defaultHeaderBufferSize)
 		conf.Chain.L1HeaderBufferSize = defaultHeaderBufferSize
 	}
 
 	if conf.Chain.L2HeaderBufferSize == 0 {
-		logger.Info("setting default L2 header buffer", "size", defaultHeaderBufferSize)
+		log.Info("setting default L2 header buffer", "size", defaultHeaderBufferSize)
 		conf.Chain.L2HeaderBufferSize = defaultHeaderBufferSize
 	}
 
-	logger.Info("loaded config")
+	log.Info("loaded config")
 	return conf, nil
 }

indexer/config/config_test.go

@@ -192,9 +192,11 @@ func Test_AsSliceSuccess(t *testing.T) {
 
 	slice, err := testCfg.AsSlice()
 	require.NoError(t, err)
-	require.Equal(t, len(slice), 4)
+	require.Equal(t, len(slice), 5)
 	require.Equal(t, slice[0].String(), testCfg.OptimismPortalProxy.String())
 	require.Equal(t, slice[1].String(), testCfg.L2OutputOracleProxy.String())
 	require.Equal(t, slice[2].String(), testCfg.L1CrossDomainMessengerProxy.String())
 	require.Equal(t, slice[3].String(), testCfg.L1StandardBridgeProxy.String())
+
+	// LegacyCanonicalTransactionChain is the 4th slot
 }

indexer/config/presets.go

@@ -10,23 +10,28 @@ var presetConfigs = map[int]ChainConfig{
 	// OP Mainnet
 	10: {
 		L1Contracts: L1Contracts{
-			OptimismPortalProxy:         common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
-			L2OutputOracleProxy:         common.HexToAddress("0xdfe97868233d1aa22e815a266982f2cf17685a27"),
-			L1CrossDomainMessengerProxy: common.HexToAddress("0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1"),
-			L1StandardBridgeProxy:       common.HexToAddress("0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"),
-			// LegacyCanonicalTransactionChain: common.HexToAddress("0x5e4e65926ba27467555eb562121fac00d24e9dd2"),
+			OptimismPortalProxy:             common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
+			L2OutputOracleProxy:             common.HexToAddress("0xdfe97868233d1aa22e815a266982f2cf17685a27"),
+			L1CrossDomainMessengerProxy:     common.HexToAddress("0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1"),
+			L1StandardBridgeProxy:           common.HexToAddress("0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"),
+			LegacyCanonicalTransactionChain: common.HexToAddress("0x5e4e65926ba27467555eb562121fac00d24e9dd2"),
 		},
-		L1StartingHeight: 13596466,
+		L1StartingHeight:        13596466,
+		L1BedrockStartingHeight: 17422590,
+		L2BedrockStartingHeight: 105235063,
 	},
 	// OP Goerli
 	420: {
 		L1Contracts: L1Contracts{
-			OptimismPortalProxy:         common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
-			L2OutputOracleProxy:         common.HexToAddress("0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"),
-			L1CrossDomainMessengerProxy: common.HexToAddress("0x5086d1eEF304eb5284A0f6720f79403b4e9bE294"),
-			L1StandardBridgeProxy:       common.HexToAddress("0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"),
+			OptimismPortalProxy:             common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
+			L2OutputOracleProxy:             common.HexToAddress("0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"),
+			L1CrossDomainMessengerProxy:     common.HexToAddress("0x5086d1eEF304eb5284A0f6720f79403b4e9bE294"),
+			L1StandardBridgeProxy:           common.HexToAddress("0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"),
+			LegacyCanonicalTransactionChain: common.HexToAddress("0x607F755149cFEB3a14E1Dc3A4E2450Cde7dfb04D"),
 		},
-		L1StartingHeight: 7017096,
+		L1StartingHeight:        7017096,
+		L1BedrockStartingHeight: 8300214,
+		L2BedrockStartingHeight: 4061224,
 	},
 	// Base Mainnet
 	8453: {

indexer/e2e_tests/utils/cross_domain_messages.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
 type CrossDomainMessengerSentMessage struct {
@@ -57,5 +58,10 @@ func CrossDomainMessengerSentMessageHash(sentMessage *bindings.CrossDomainMessen
 		return common.Hash{}, err
 	}
 
-	return contracts.CrossDomainMessageHash(abi, sentMessage, value)
+	calldata, err := contracts.CrossDomainMessageCalldata(abi, sentMessage, value)
+	if err != nil {
+		return common.Hash{}, err
+	}
+
+	return crypto.Keccak256Hash(calldata), nil
 }

indexer/etl/etl.go

@@ -29,9 +29,10 @@ type ETL struct {
 	headerBufferSize uint64
 	headerTraversal  *node.HeaderTraversal
 
-	ethClient  node.EthClient
 	contracts  []common.Address
 	etlBatches chan ETLBatch
+
+	EthClient node.EthClient
 }
 
 type ETLBatch struct {
@@ -104,7 +105,7 @@ func (etl *ETL) processBatch(headers []types.Header) error {
 	}
 
 	headersWithLog := make(map[common.Hash]bool, len(headers))
-	logs, err := etl.ethClient.FilterLogs(ethereum.FilterQuery{FromBlock: firstHeader.Number, ToBlock: lastHeader.Number, Addresses: etl.contracts})
+	logs, err := etl.EthClient.FilterLogs(ethereum.FilterQuery{FromBlock: firstHeader.Number, ToBlock: lastHeader.Number, Addresses: etl.contracts})
 	if err != nil {
 		batchLog.Info("unable to extract logs", "err", err)
 		return err

indexer/etl/l1_etl.go

@@ -66,9 +66,10 @@ func NewL1ETL(cfg Config, log log.Logger, db *database.DB, metrics Metricer, cli
 		log:             log,
 		metrics:         metrics,
 		headerTraversal: node.NewHeaderTraversal(client, fromHeader, cfg.ConfirmationDepth),
-		ethClient:       client,
 		contracts:       cSlice,
 		etlBatches:      etlBatches,
+
+		EthClient: client,
 	}
 
 	return &L1ETL{ETL: etl, db: db, mu: new(sync.Mutex)}, nil

indexer/etl/l2_etl.go

@@ -50,9 +50,10 @@ func NewL2ETL(cfg Config, log log.Logger, db *database.DB, metrics Metricer, cli
 		log:             log,
 		metrics:         metrics,
 		headerTraversal: node.NewHeaderTraversal(client, fromHeader, cfg.ConfirmationDepth),
-		ethClient:       client,
 		contracts:       l2Contracts,
 		etlBatches:      etlBatches,
+
+		EthClient: client,
 	}
 
 	return &L2ETL{ETL: etl, db: db}, nil

indexer/indexer.toml

@@ -2,7 +2,6 @@
 # Can configure them manually or use a preset l2 ChainId for known chains including OP Mainnet, OP Goerli, Base, Base Goerli, Zora, and Zora goerli
 [chain]
 
-# OP Goerli
 preset = $INDEXER_CHAIN_PRESET
 
 # L1 Config

indexer/migrations/20230523_create_schema.sql

@@ -29,7 +29,7 @@ CREATE TABLE IF NOT EXISTS l2_block_headers (
     hash        VARCHAR PRIMARY KEY,
     parent_hash VARCHAR NOT NULL UNIQUE,
     number      UINT256 NOT NULL UNIQUE,
-    timestamp   INTEGER NOT NULL UNIQUE CHECK (timestamp > 0),
+    timestamp   INTEGER NOT NULL,
 
     -- Raw Data
     rlp_bytes VARCHAR NOT NULL

indexer/node/client.go

@@ -29,6 +29,8 @@ type EthClient interface {
 	BlockHeaderByHash(common.Hash) (*types.Header, error)
 	BlockHeadersByRange(*big.Int, *big.Int) ([]types.Header, error)
 
+	TxByHash(common.Hash) (*types.Transaction, error)
+
 	StorageHash(common.Address, *big.Int) (common.Hash, error)
 	FilterLogs(ethereum.FilterQuery) ([]types.Log, error)
 }
@@ -147,6 +149,21 @@ func (c *client) BlockHeadersByRange(startHeight, endHeight *big.Int) ([]types.H
 	return headers, nil
 }
 
+func (c *client) TxByHash(hash common.Hash) (*types.Transaction, error) {
+	ctxwt, cancel := context.WithTimeout(context.Background(), defaultRequestTimeout)
+	defer cancel()
+
+	var tx *types.Transaction
+	err := c.rpc.CallContext(ctxwt, &tx, "eth_getTransactionByHash", hash)
+	if err != nil {
+		return nil, err
+	} else if tx == nil {
+		return nil, ethereum.NotFound
+	}
+
+	return tx, nil
+}
+
 // StorageHash returns the sha3 of the storage root for the specified account
 func (c *client) StorageHash(address common.Address, blockNumber *big.Int) (common.Hash, error) {
 	ctxwt, cancel := context.WithTimeout(context.Background(), defaultRequestTimeout)

indexer/node/mocks.go

@@ -31,6 +31,11 @@ func (m *MockEthClient) BlockHeadersByRange(from, to *big.Int) ([]types.Header,
 	return args.Get(0).([]types.Header), args.Error(1)
 }
 
+func (m *MockEthClient) TxByHash(hash common.Hash) (*types.Transaction, error) {
+	args := m.Called(hash)
+	return args.Get(0).(*types.Transaction), args.Error(1)
+}
+
 func (m *MockEthClient) StorageHash(address common.Address, blockNumber *big.Int) (common.Hash, error) {
 	args := m.Called(address, blockNumber)
 	return args.Get(0).(common.Hash), args.Error(1)

indexer/processors/bridge.go

@@ -124,19 +124,78 @@ func (b *BridgeProcessor) Start(ctx context.Context) error {
 			fromL2Height = new(big.Int).Add(b.LatestL2Header.Number, bigint.One)
 		}
 
+		l1BedrockStartingHeight := big.NewInt(int64(b.chainConfig.L1BedrockStartingHeight))
+		l2BedrockStartingHeight := big.NewInt(int64(b.chainConfig.L2BedrockStartingHeight))
+
 		batchLog := b.log.New("epoch_start_number", fromL1Height, "epoch_end_number", toL1Height)
 		batchLog.Info("unobserved epochs")
 		err = b.db.Transaction(func(tx *database.DB) error {
+			// In the event where we have a large number of un-observed blocks, group the block range
+			// on the order of 10k blocks at a time. If this turns out to be a bottleneck, we can
+			// parallelize these operations
+			maxBlockRange := uint64(10_000)
 			l1BridgeLog := b.log.New("bridge", "l1")
 			l2BridgeLog := b.log.New("bridge", "l2")
 
-			// In the event where we have a large number of un-observed blocks, group the block range
-			// on the order of 10k blocks at a time. If this turns out to be a bottleneck, we can
-			// parallelize these operations for significant improvements as well
-			l1BlockGroups := bigint.Grouped(fromL1Height, toL1Height, 10_000)
-			l2BlockGroups := bigint.Grouped(fromL2Height, toL2Height, 10_000)
+			// FOR OP-MAINNET, OP-GOERLI ONLY! Specially handle the existence of pre-bedrock blocks
+			if l1BedrockStartingHeight.Cmp(fromL1Height) > 0 {
+				l1BridgeLog := l1BridgeLog.New("mode", "legacy")
+				l2BridgeLog := l2BridgeLog.New("mode", "legacy")
+
+				legacyFromL1Height, legacyToL1Height := fromL1Height, toL1Height
+				legacyFromL2Height, legacyToL2Height := fromL2Height, toL2Height
+				if l1BedrockStartingHeight.Cmp(toL1Height) <= 0 {
+					legacyToL1Height = new(big.Int).Sub(l1BedrockStartingHeight, big.NewInt(1))
+					legacyToL2Height = new(big.Int).Sub(l2BedrockStartingHeight, big.NewInt(1))
+				}
+
+				// First, find all possible initiated bridge events
+				l1BlockGroups := bigint.Grouped(legacyFromL1Height, legacyToL1Height, maxBlockRange)
+				l2BlockGroups := bigint.Grouped(legacyFromL2Height, legacyToL2Height, maxBlockRange)
+				for _, group := range l1BlockGroups {
+					log := l1BridgeLog.New("from_l1_block_number", group.Start, "to_l1_block_number", group.End)
+					log.Info("scanning for initiated bridge events")
+					if err := bridge.LegacyL1ProcessInitiatedBridgeEvents(log, tx, b.chainConfig, group.Start, group.End); err != nil {
+						return err
+					}
+				}
+				for _, group := range l2BlockGroups {
+					log := l2BridgeLog.New("from_l2_block_number", group.Start, "to_l2_block_number", group.End)
+					log.Info("scanning for initiated bridge events")
+					if err := bridge.LegacyL2ProcessInitiatedBridgeEvents(log, tx, group.Start, group.End); err != nil {
+						return err
+					}
+				}
+
+				// Now that all initiated events have been indexed, it is ensured that all finalization can find their counterpart.
+				for _, group := range l1BlockGroups {
+					log := l1BridgeLog.New("from_l1_block_number", group.Start, "to_l1_block_number", group.End)
+					log.Info("scanning for finalized bridge events")
+					if err := bridge.LegacyL1ProcessFinalizedBridgeEvents(log, tx, b.l1Etl.EthClient, b.chainConfig, group.Start, group.End); err != nil {
+						return err
+					}
+				}
+				for _, group := range l2BlockGroups {
+					log := l2BridgeLog.New("from_l2_block_number", group.Start, "to_l2_block_number", group.End)
+					log.Info("scanning for finalized bridge events")
+					if err := bridge.LegacyL2ProcessFinalizedBridgeEvents(log, tx, group.Start, group.End); err != nil {
+						return err
+					}
+				}
+
+				if legacyToL1Height.Cmp(toL1Height) == 0 {
+					// a-ok! entire batch was legacy blocks
+					return nil
+				}
+
+				batchLog.Info("detected switch to bedrock", "l1_bedrock_starting_height", l1BedrockStartingHeight, "l2_bedrock_starting_height", l2BedrockStartingHeight)
+				fromL1Height = l1BedrockStartingHeight
+				fromL2Height = l2BedrockStartingHeight
+			}
 
 			// First, find all possible initiated bridge events
+			l1BlockGroups := bigint.Grouped(fromL1Height, toL1Height, maxBlockRange)
+			l2BlockGroups := bigint.Grouped(fromL2Height, toL2Height, maxBlockRange)
 			for _, group := range l1BlockGroups {
 				log := l1BridgeLog.New("from_block_number", group.Start, "to_block_number", group.End)
 				log.Info("scanning for initiated bridge events")
@@ -181,4 +240,5 @@ func (b *BridgeProcessor) Start(ctx context.Context) error {
 			b.LatestL2Header = latestEpoch.L2BlockHeader.RLPHeader.Header()
 		}
 	}
+
 }

indexer/processors/bridge/l1_bridge_processor.go

@@ -12,7 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-// L1ProcessInitiatedBridgeEvents will query the database for new bridge events that have been initiated between
+// L1ProcessInitiatedBridgeEvents will query the database for bridge events that have been initiated between
 // the specified block range. This covers every part of the multi-layered stack:
 //  1. OptimismPortal
 //  2. L1CrossDomainMessenger

indexer/processors/bridge/l2_bridge_processor.go

@@ -12,7 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-// L2ProcessInitiatedBridgeEvents will query the database for new bridge events that have been initiated between
+// L2ProcessInitiatedBridgeEvents will query the database for bridge events that have been initiated between
 // the specified block range. This covers every part of the multi-layered stack:
 //  1. OptimismPortal
 //  2. L2CrossDomainMessenger

indexer/processors/contracts/cross_domain_messenger.go

@@ -18,7 +18,7 @@ var (
 	bytesType, _   = abi.NewType("bytes", "", nil)
 	addressType, _ = abi.NewType("address", "", nil)
 
-	legacyCrossDomainMessengerRelayMessageMethod = abi.NewMethod(
+	CrossDomainMessengerLegacyRelayMessageEncoding = abi.NewMethod(
 		"relayMessage",
 		"relayMessage",
 		abi.Function,
@@ -26,18 +26,21 @@ var (
 		false,      // isConst
 		true,       // payable
 		abi.Arguments{ // inputs
-			{Name: "sender", Type: addressType},
 			{Name: "target", Type: addressType},
+			{Name: "sender", Type: addressType},
 			{Name: "data", Type: bytesType},
 			{Name: "nonce", Type: uint256Type},
+			// The actual transaction on the legacy L1CrossDomainMessenger has a trailing
+			// proof argument but is ignored for the `XDomainCallData` encoding
 		},
 		abi.Arguments{}, // outputs
 	)
 )
 
 type CrossDomainMessengerSentMessageEvent struct {
-	Event         *database.ContractEvent
-	BridgeMessage database.BridgeMessage
+	Event           *database.ContractEvent
+	MessageCalldata []byte
+	BridgeMessage   database.BridgeMessage
 }
 
 type CrossDomainMessengerRelayedMessageEvent struct {
@@ -58,7 +61,6 @@ func CrossDomainMessengerSentMessageEvents(chainSelector string, contractAddress
 		return nil, err
 	}
 	if len(sentMessageEvents) == 0 {
-		// prevent the following db queries if we dont need them
 		return nil, nil
 	}
 
@@ -68,10 +70,13 @@ func CrossDomainMessengerSentMessageEvents(chainSelector string, contractAddress
 	if err != nil {
 		return nil, err
 	}
-	if len(sentMessageEvents) != len(sentMessageExtensionEvents) {
-		return nil, fmt.Errorf("mismatch in SentMessage events. %d sent messages & %d sent message extensions", len(sentMessageEvents), len(sentMessageExtensionEvents))
+	if len(sentMessageExtensionEvents) > len(sentMessageEvents) {
+		return nil, fmt.Errorf("mismatch. %d sent messages & %d sent message extensions", len(sentMessageEvents), len(sentMessageExtensionEvents))
 	}
 
+	// We handle version zero messages uniquely since the first version of cross domain messages
+	// do not have the SentMessageExtension1 event emitted, introduced in version 1.
+	numVersionZeroMessages := len(sentMessageEvents) - len(sentMessageExtensionEvents)
 	crossDomainSentMessages := make([]CrossDomainMessengerSentMessageEvent, len(sentMessageEvents))
 	for i := range sentMessageEvents {
 		sentMessage := bindings.CrossDomainMessengerSentMessage{Raw: *sentMessageEvents[i].RLPLog}
@@ -79,34 +84,45 @@ func CrossDomainMessengerSentMessageEvents(chainSelector string, contractAddress
 		if err != nil {
 			return nil, err
 		}
-		sentMessageExtension := bindings.CrossDomainMessengerSentMessageExtension1{Raw: *sentMessageExtensionEvents[i].RLPLog}
-		err = UnpackLog(&sentMessageExtension, sentMessageExtensionEvents[i].RLPLog, sentMessageExtensionEventAbi.Name, crossDomainMessengerAbi)
-		if err != nil {
-			return nil, err
+
+		version, _ := DecodeVersionedNonce(sentMessage.MessageNonce)
+		if i < numVersionZeroMessages && version != 0 {
+			return nil, fmt.Errorf("expected version zero nonce. nonce %d tx_hash %s", sentMessage.MessageNonce, sentMessage.Raw.TxHash)
 		}
 
-		messageHash, err := CrossDomainMessageHash(crossDomainMessengerAbi, &sentMessage, sentMessageExtension.Value)
+		// In version zero, to value is bridged through the cross domain messenger.
+		value := big.NewInt(0)
+		if version > 0 {
+			sentMessageExtension := bindings.CrossDomainMessengerSentMessageExtension1{Raw: *sentMessageExtensionEvents[i].RLPLog}
+			err = UnpackLog(&sentMessageExtension, sentMessageExtensionEvents[i].RLPLog, sentMessageExtensionEventAbi.Name, crossDomainMessengerAbi)
+			if err != nil {
+				return nil, err
+			}
+			value = sentMessageExtension.Value
+		}
+
+		messageCalldata, err := CrossDomainMessageCalldata(crossDomainMessengerAbi, &sentMessage, value)
 		if err != nil {
 			return nil, err
 		}
 
 		crossDomainSentMessages[i] = CrossDomainMessengerSentMessageEvent{
-			Event: &sentMessageEvents[i],
+			Event:           &sentMessageEvents[i],
+			MessageCalldata: messageCalldata,
 			BridgeMessage: database.BridgeMessage{
-				MessageHash:          messageHash,
+				MessageHash:          crypto.Keccak256Hash(messageCalldata),
 				Nonce:                sentMessage.MessageNonce,
 				SentMessageEventGUID: sentMessageEvents[i].GUID,
 				GasLimit:             sentMessage.GasLimit,
 				Tx: database.Transaction{
 					FromAddress: sentMessage.Sender,
 					ToAddress:   sentMessage.Target,
-					Amount:      sentMessageExtension.Value,
+					Amount:      value,
 					Data:        sentMessage.Message,
 					Timestamp:   sentMessageEvents[i].Timestamp,
 				},
 			},
 		}
-
 	}
 
 	return crossDomainSentMessages, nil
@@ -142,26 +158,25 @@ func CrossDomainMessengerRelayedMessageEvents(chainSelector string, contractAddr
 	return crossDomainRelayedMessages, nil
 }
 
-// Replica of `Hashing.sol#hashCrossDomainMessage` solidity implementation
-func CrossDomainMessageHash(abi *abi.ABI, sentMsg *bindings.CrossDomainMessengerSentMessage, value *big.Int) (common.Hash, error) {
+// Replica of `Encoding.sol#encodeCrossDomainMessage` solidity implementation
+func CrossDomainMessageCalldata(abi *abi.ABI, sentMsg *bindings.CrossDomainMessengerSentMessage, value *big.Int) ([]byte, error) {
 	version, _ := DecodeVersionedNonce(sentMsg.MessageNonce)
 	switch version {
 	case 0:
 		// Legacy Message
-		inputBytes, err := legacyCrossDomainMessengerRelayMessageMethod.Inputs.Pack(sentMsg.Sender, sentMsg.Target, sentMsg.Message, sentMsg.MessageNonce)
+		inputBytes, err := CrossDomainMessengerLegacyRelayMessageEncoding.Inputs.Pack(sentMsg.Target, sentMsg.Sender, sentMsg.Message, sentMsg.MessageNonce)
 		if err != nil {
-			return common.Hash{}, err
+			return nil, err
 		}
-		msgBytes := append(legacyCrossDomainMessengerRelayMessageMethod.ID, inputBytes...)
-		return crypto.Keccak256Hash(msgBytes), nil
+		return append(CrossDomainMessengerLegacyRelayMessageEncoding.ID, inputBytes...), 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 nil, err
 		}
-		return crypto.Keccak256Hash(msgBytes), nil
+		return msgBytes, nil
 	}
 
-	return common.Hash{}, fmt.Errorf("unsupported cross domain messenger version: %d", version)
+	return nil, fmt.Errorf("unsupported cross domain messenger version: %d", version)
 }

indexer/processors/contracts/legacy_ctc.go

+package contracts
+
+import (
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/bigint"
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	legacy_bindings "github.com/ethereum-optimism/optimism/op-bindings/legacy-bindings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type LegacyCTCDepositEvent struct {
+	Event    *database.ContractEvent
+	Tx       database.Transaction
+	TxHash   common.Hash
+	GasLimit *big.Int
+}
+
+func LegacyCTCDepositEvents(contractAddress common.Address, db *database.DB, fromHeight, toHeight *big.Int) ([]LegacyCTCDepositEvent, error) {
+	ctcAbi, err := legacy_bindings.CanonicalTransactionChainMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	transactionEnqueuedEventAbi := ctcAbi.Events["TransactionEnqueued"]
+	contractEventFilter := database.ContractEvent{ContractAddress: contractAddress, EventSignature: transactionEnqueuedEventAbi.ID}
+	events, err := db.ContractEvents.L1ContractEventsWithFilter(contractEventFilter, fromHeight, toHeight)
+	if err != nil {
+		return nil, err
+	}
+
+	ctcTxDeposits := make([]LegacyCTCDepositEvent, len(events))
+	for i := range events {
+		txEnqueued := legacy_bindings.CanonicalTransactionChainTransactionEnqueued{Raw: *events[i].RLPLog}
+		err = UnpackLog(&txEnqueued, events[i].RLPLog, transactionEnqueuedEventAbi.Name, ctcAbi)
+		if err != nil {
+			return nil, err
+		}
+
+		// Enqueued Deposits do not carry a `msg.value` amount. ETH is only minted on L2 via the L1StandardBrige
+		ctcTxDeposits[i] = LegacyCTCDepositEvent{
+			Event:    &events[i].ContractEvent,
+			GasLimit: txEnqueued.GasLimit,
+			TxHash:   types.NewTransaction(0, txEnqueued.Target, bigint.Zero, txEnqueued.GasLimit.Uint64(), nil, txEnqueued.Data).Hash(),
+			Tx: database.Transaction{
+				FromAddress: txEnqueued.L1TxOrigin,
+				ToAddress:   txEnqueued.Target,
+				Amount:      bigint.Zero,
+				Data:        txEnqueued.Data,
+				Timestamp:   events[i].Timestamp,
+			},
+		}
+	}
+
+	return ctcTxDeposits, nil
+}

indexer/processors/contracts/legacy_standard_bridge.go

+package contracts
+
+import (
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type LegacyBridgeEvent struct {
+	Event          *database.ContractEvent
+	BridgeTransfer database.BridgeTransfer
+}
+
+func L1StandardBridgeLegacyDepositInitiatedEvents(contractAddress common.Address, db *database.DB, fromHeight, toHeight *big.Int) ([]LegacyBridgeEvent, error) {
+	l1StandardBridgeAbi, err := bindings.L1StandardBridgeMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	// The L1StandardBridge contains the legacy events
+	ethDepositEventAbi := l1StandardBridgeAbi.Events["ETHDepositInitiated"]
+	erc20DepositEventAbi := l1StandardBridgeAbi.Events["ERC20DepositInitiated"]
+
+	// Grab both ETH & ERC20 Events
+	ethDepositEvents, err := db.ContractEvents.L1ContractEventsWithFilter(database.ContractEvent{ContractAddress: contractAddress, EventSignature: ethDepositEventAbi.ID}, fromHeight, toHeight)
+	if err != nil {
+		return nil, err
+	}
+	erc20DepositEvents, err := db.ContractEvents.L1ContractEventsWithFilter(database.ContractEvent{ContractAddress: contractAddress, EventSignature: erc20DepositEventAbi.ID}, fromHeight, toHeight)
+	if err != nil {
+		return nil, err
+	}
+
+	// Represent the ETH deposits via the ETH ERC20 predeploy address
+	deposits := make([]LegacyBridgeEvent, len(ethDepositEvents)+len(erc20DepositEvents))
+	for i := range ethDepositEvents {
+		bridgeEvent := bindings.L1StandardBridgeETHDepositInitiated{Raw: *ethDepositEvents[i].RLPLog}
+		err := UnpackLog(&bridgeEvent, &bridgeEvent.Raw, ethDepositEventAbi.Name, l1StandardBridgeAbi)
+		if err != nil {
+			return nil, err
+		}
+		deposits[i] = LegacyBridgeEvent{
+			Event: &ethDepositEvents[i].ContractEvent,
+			BridgeTransfer: database.BridgeTransfer{
+				TokenPair: database.ETHTokenPair,
+				Tx: database.Transaction{
+					FromAddress: bridgeEvent.From,
+					ToAddress:   bridgeEvent.To,
+					Amount:      bridgeEvent.Amount,
+					Data:        bridgeEvent.ExtraData,
+					Timestamp:   ethDepositEvents[i].Timestamp,
+				},
+			},
+		}
+	}
+	for i := range erc20DepositEvents {
+		bridgeEvent := bindings.L1StandardBridgeERC20DepositInitiated{Raw: *erc20DepositEvents[i].RLPLog}
+		err := UnpackLog(&bridgeEvent, &bridgeEvent.Raw, erc20DepositEventAbi.Name, l1StandardBridgeAbi)
+		if err != nil {
+			return nil, err
+		}
+		deposits[len(ethDepositEvents)+i] = LegacyBridgeEvent{
+			Event: &erc20DepositEvents[i].ContractEvent,
+			BridgeTransfer: database.BridgeTransfer{
+				TokenPair: database.TokenPair{LocalTokenAddress: bridgeEvent.L1Token, RemoteTokenAddress: bridgeEvent.L2Token},
+				Tx: database.Transaction{
+					FromAddress: bridgeEvent.From,
+					ToAddress:   bridgeEvent.To,
+					Amount:      bridgeEvent.Amount,
+					Data:        bridgeEvent.ExtraData,
+					Timestamp:   erc20DepositEvents[i].Timestamp,
+				},
+			},
+		}
+	}
+
+	return deposits, nil
+}
+
+func L2StandardBridgeLegacyWithdrawalInitiatedEvents(contractAddress common.Address, db *database.DB, fromHeight, toHeight *big.Int) ([]LegacyBridgeEvent, error) {
+	l2StandardBridgeAbi, err := bindings.L2StandardBridgeMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	withdrawalInitiatedEventAbi := l2StandardBridgeAbi.Events["WithdrawalInitiated"]
+	withdrawalEvents, err := db.ContractEvents.L2ContractEventsWithFilter(database.ContractEvent{ContractAddress: contractAddress, EventSignature: withdrawalInitiatedEventAbi.ID}, fromHeight, toHeight)
+	if err != nil {
+		return nil, err
+	}
+
+	withdrawals := make([]LegacyBridgeEvent, len(withdrawalEvents))
+	for i := range withdrawalEvents {
+		bridgeEvent := bindings.L2StandardBridgeWithdrawalInitiated{Raw: *withdrawalEvents[i].RLPLog}
+		err := UnpackLog(&bridgeEvent, &bridgeEvent.Raw, withdrawalInitiatedEventAbi.Name, l2StandardBridgeAbi)
+		if err != nil {
+			return nil, err
+		}
+
+		withdrawals[i] = LegacyBridgeEvent{
+			Event: &withdrawalEvents[i].ContractEvent,
+			BridgeTransfer: database.BridgeTransfer{
+				TokenPair: database.ETHTokenPair,
+				Tx: database.Transaction{
+					FromAddress: bridgeEvent.From,
+					ToAddress:   bridgeEvent.To,
+					Amount:      bridgeEvent.Amount,
+					Data:        bridgeEvent.ExtraData,
+					Timestamp:   withdrawalEvents[i].Timestamp,
+				},
+			},
+		}
+	}
+
+	return withdrawals, nil
+}