Merge pull request #6671 from ethereum-optimism/08-08-store_rlp_bytes_of_headers/logs

feat(indexer): Store RLP bytes of logs/headers when indexing them

indexer/database/blocks.go

@@ -22,6 +22,8 @@ type BlockHeader struct {
 	ParentHash common.Hash `gorm:"serializer:json"`
 	Number     U256
 	Timestamp  uint64
+
+	GethHeader *GethHeader `gorm:"serializer:rlp;column:rlp_bytes"`
 }
 
 func BlockHeaderFromGethHeader(header *types.Header) BlockHeader {
@@ -30,6 +32,8 @@ func BlockHeaderFromGethHeader(header *types.Header) BlockHeader {
 		ParentHash: header.ParentHash,
 		Number:     U256{Int: header.Number},
 		Timestamp:  header.Time,
+
+		GethHeader: (*GethHeader)(header),
 	}
 }
 

indexer/database/contract_events.go

@@ -16,26 +16,37 @@ import (
  */
 
 type ContractEvent struct {
-	GUID            uuid.UUID   `gorm:"primaryKey"`
-	BlockHash       common.Hash `gorm:"serializer:json"`
-	TransactionHash common.Hash `gorm:"serializer:json"`
+	GUID            uuid.UUID      `gorm:"primaryKey"`
+	BlockHash       common.Hash    `gorm:"serializer:json"`
+	ContractAddress common.Address `gorm:"serializer:json"`
+	TransactionHash common.Hash    `gorm:"serializer:json"`
 
 	EventSignature common.Hash `gorm:"serializer:json"`
 	LogIndex       uint64
 	Timestamp      uint64
+
+	GethLog *types.Log `gorm:"serializer:rlp;column:rlp_bytes"`
 }
 
 func ContractEventFromGethLog(log *types.Log, timestamp uint64) ContractEvent {
+	eventSig := common.Hash{}
+	if len(log.Topics) > 0 {
+		eventSig = log.Topics[0]
+	}
+
 	return ContractEvent{
 		GUID: uuid.New(),
 
 		BlockHash:       log.BlockHash,
+		ContractAddress: log.Address,
 		TransactionHash: log.TxHash,
 
-		EventSignature: log.Topics[0],
+		EventSignature: eventSig,
 		LogIndex:       uint64(log.Index),
 
 		Timestamp: timestamp,
+
+		GethLog: log,
 	}
 }
 

indexer/database/rlp_serializer.go

+package database
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/rlp"
+
+	"gorm.io/gorm/schema"
+)
+
+type RLPSerializer struct{}
+
+type RLPInterface interface {
+	rlp.Encoder
+	rlp.Decoder
+}
+
+func init() {
+	schema.RegisterSerializer("rlp", RLPSerializer{})
+}
+
+func (RLPSerializer) Scan(ctx context.Context, field *schema.Field, dst reflect.Value, dbValue interface{}) error {
+	fieldValue := reflect.New(field.FieldType)
+	if dbValue != nil {
+		var bytes []byte
+		switch v := dbValue.(type) {
+		case []byte:
+			bytes = v
+		case string:
+			b, err := hexutil.Decode(v)
+			if err != nil {
+				return err
+			}
+			bytes = b
+		default:
+			return fmt.Errorf("unrecognized RLP bytes: %#v", dbValue)
+		}
+
+		if len(bytes) > 0 {
+			err := rlp.DecodeBytes(bytes, fieldValue.Interface())
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	field.ReflectValueOf(ctx, dst).Set(fieldValue.Elem())
+	return nil
+}
+
+func (RLPSerializer) Value(ctx context.Context, field *schema.Field, dst reflect.Value, fieldValue interface{}) (interface{}, error) {
+	// Even though rlp.Encode takes an interface and will error out if the passed interface does not
+	// satisfy the interface, we check here since we also want to make sure this type satisfies the
+	// rlp.Decoder interface as well
+	i := reflect.TypeOf(new(RLPInterface)).Elem()
+	if !reflect.TypeOf(fieldValue).Implements(i) {
+		return nil, fmt.Errorf("%T does not satisfy RLP Encoder & Decoder interface", fieldValue)
+	}
+
+	rlpBytes, err := rlp.EncodeToBytes(fieldValue)
+	if err != nil {
+		return nil, err
+	}
+
+	return hexutil.Bytes(rlpBytes).MarshalText()
+}

indexer/database/types.go

@@ -3,8 +3,12 @@ package database
 import (
 	"database/sql/driver"
 	"errors"
+	"io"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/jackc/pgtype"
 )
 
@@ -13,7 +17,7 @@ var big10 = big.NewInt(10)
 
 var ErrU256Overflow = errors.New("number exceeds u256")
 var ErrU256ContainsDecimal = errors.New("number contains fractional digits")
-var ErrU256NotNull = errors.New("number cannot be null")
+var ErrU256Null = errors.New("number cannot be null")
 
 // U256 is a wrapper over big.Int that conforms to the database U256 numeric domain type
 type U256 struct {
@@ -30,7 +34,7 @@ func (u256 *U256) Scan(src interface{}) error {
 	} else if numeric.Exp < 0 {
 		return ErrU256ContainsDecimal
 	} else if numeric.Status == pgtype.Null {
-		return ErrU256NotNull
+		return ErrU256Null
 	}
 
 	// factor in the powers of 10
@@ -54,7 +58,7 @@ func (u256 *U256) Scan(src interface{}) error {
 func (u256 U256) Value() (driver.Value, error) {
 	// check bounds
 	if u256.Int == nil {
-		return nil, ErrU256NotNull
+		return nil, ErrU256Null
 	} else if u256.Int.Cmp(u256BigIntOverflow) >= 0 {
 		return nil, ErrU256Overflow
 	}
@@ -63,3 +67,29 @@ func (u256 U256) Value() (driver.Value, error) {
 	numeric := pgtype.Numeric{Int: u256.Int, Status: pgtype.Present}
 	return numeric.Value()
 }
+
+type GethHeader types.Header
+
+func (h *GethHeader) EncodeRLP(w io.Writer) error {
+	return types.NewBlockWithHeader((*types.Header)(h)).EncodeRLP(w)
+}
+
+func (h *GethHeader) DecodeRLP(s *rlp.Stream) error {
+	block := new(types.Block)
+	err := block.DecodeRLP(s)
+	if err != nil {
+		return err
+	}
+
+	header := block.Header()
+	*h = (GethHeader)(*header)
+	return nil
+}
+
+func (h *GethHeader) Header() *types.Header {
+	return (*types.Header)(h)
+}
+
+func (h *GethHeader) Hash() common.Hash {
+	return h.Header().Hash()
+}

indexer/e2e_tests/blocks_e2e_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/rlp"
 
 	"github.com/stretchr/testify/require"
 )
@@ -62,6 +63,9 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.Equal(t, header.Hash(), indexedHeader.Hash)
 			require.Equal(t, header.ParentHash, indexedHeader.ParentHash)
 			require.Equal(t, header.Time, indexedHeader.Timestamp)
+
+			// ensure the right rlp encoding is stored. checking the hashes sufficies
+			require.Equal(t, header.Hash(), indexedHeader.GethHeader.Hash())
 		}
 	})
 
@@ -116,9 +120,17 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.NoError(t, err)
 			require.Equal(t, log.Topics[0], contractEvent.EventSignature)
 			require.Equal(t, log.BlockHash, contractEvent.BlockHash)
+			require.Equal(t, log.Address, contractEvent.ContractAddress)
 			require.Equal(t, log.TxHash, contractEvent.TransactionHash)
 			require.Equal(t, log.Index, uint(contractEvent.LogIndex))
 
+			// ensure the right rlp encoding of the contract log is stored
+			logRlp, err := rlp.EncodeToBytes(&log)
+			require.NoError(t, err)
+			contractEventRlp, err := rlp.EncodeToBytes(contractEvent.GethLog)
+			require.NoError(t, err)
+			require.ElementsMatch(t, logRlp, contractEventRlp)
+
 			// ensure the block is also indexed
 			block, err := testSuite.L1Client.BlockByNumber(testCtx, big.NewInt(int64(log.BlockNumber)))
 			require.NoError(t, err)
@@ -131,6 +143,10 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.Equal(t, block.ParentHash(), l1BlockHeader.ParentHash)
 			require.Equal(t, block.Number(), l1BlockHeader.Number.Int)
 			require.Equal(t, block.Time(), l1BlockHeader.Timestamp)
+
+			// ensure the right rlp encoding is stored. checking the hashes
+			// suffices as it is based on the rlp bytes of the header
+			require.Equal(t, block.Hash(), l1BlockHeader.GethHeader.Hash())
 		}
 	})
 }

indexer/migrations/20230523_create_schema.sql

@@ -7,18 +7,25 @@ CREATE DOMAIN UINT256 AS NUMERIC
  */
 
 CREATE TABLE IF NOT EXISTS l1_block_headers (
+    -- Searchable fields
 	hash        VARCHAR NOT NULL PRIMARY KEY,
 	parent_hash VARCHAR NOT NULL,
 	number      UINT256 NOT NULL,
-	timestamp   INTEGER NOT NULL CHECK (timestamp > 0)
+	timestamp   INTEGER NOT NULL CHECK (timestamp > 0),
+
+    -- Raw Data
+    rlp_bytes VARCHAR NOT NULL
 );
 
 CREATE TABLE IF NOT EXISTS l2_block_headers (
-    -- Block header
+    -- Searchable fields
 	hash                     VARCHAR NOT NULL PRIMARY KEY,
 	parent_hash              VARCHAR NOT NULL,
 	number                   UINT256 NOT NULL,
-	timestamp                INTEGER NOT NULL CHECK (timestamp > 0)
+	timestamp                INTEGER NOT NULL CHECK (timestamp > 0),
+
+    -- Raw Data
+    rlp_bytes VARCHAR NOT NULL
 );
 
 /** 
@@ -26,21 +33,31 @@ CREATE TABLE IF NOT EXISTS l2_block_headers (
  */
 
 CREATE TABLE IF NOT EXISTS l1_contract_events (
+    -- Searchable fields
     guid             VARCHAR NOT NULL PRIMARY KEY,
 	block_hash       VARCHAR NOT NULL REFERENCES l1_block_headers(hash),
+    contract_address VARCHAR NOT NULL,
     transaction_hash VARCHAR NOT NULL,
-    event_signature  VARCHAR NOT NULL,
     log_index        INTEGER NOT NULL,
-    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
+    event_signature  VARCHAR NOT NULL, -- bytes32(0x0) when topics are missing
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0),
+
+    -- Raw Data
+    rlp_bytes VARCHAR NOT NULL
 );
 
 CREATE TABLE IF NOT EXISTS l2_contract_events (
+    -- Searchable fields
     guid             VARCHAR NOT NULL PRIMARY KEY,
 	block_hash       VARCHAR NOT NULL REFERENCES l2_block_headers(hash),
+    contract_address VARCHAR NOT NULL,
     transaction_hash VARCHAR NOT NULL,
-    event_signature  VARCHAR NOT NULL,
     log_index        INTEGER NOT NULL,
-    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
+    event_signature  VARCHAR NOT NULL, -- bytes32(0x0) when topics are missing
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0),
+
+    -- Raw Data
+    rlp_bytes VARCHAR NOT NULL
 );
 
 -- Tables that index finalization markers for L2 blocks.

indexer/processor/contract_events.go

@@ -9,20 +9,17 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-
-	"github.com/google/uuid"
 )
 
 type ProcessedContractEventLogIndexKey struct {
-	header common.Hash
-	index  uint
+	blockHash common.Hash
+	index     uint
 }
 
 type ProcessedContractEvents struct {
 	events            []*database.ContractEvent
 	eventsBySignature map[common.Hash][]*database.ContractEvent
 	eventByLogIndex   map[ProcessedContractEventLogIndexKey]*database.ContractEvent
-	eventLog          map[uuid.UUID]*types.Log
 }
 
 func NewProcessedContractEvents() *ProcessedContractEvents {
@@ -30,17 +27,18 @@ func NewProcessedContractEvents() *ProcessedContractEvents {
 		events:            []*database.ContractEvent{},
 		eventsBySignature: make(map[common.Hash][]*database.ContractEvent),
 		eventByLogIndex:   make(map[ProcessedContractEventLogIndexKey]*database.ContractEvent),
-		eventLog:          make(map[uuid.UUID]*types.Log),
 	}
 }
 
 func (p *ProcessedContractEvents) AddLog(log *types.Log, time uint64) *database.ContractEvent {
 	contractEvent := database.ContractEventFromGethLog(log, time)
+	emptyHash := common.Hash{}
 
 	p.events = append(p.events, &contractEvent)
-	p.eventsBySignature[contractEvent.EventSignature] = append(p.eventsBySignature[contractEvent.EventSignature], &contractEvent)
 	p.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index}] = &contractEvent
-	p.eventLog[contractEvent.GUID] = log
+	if contractEvent.EventSignature != emptyHash { // ignore anon events
+		p.eventsBySignature[contractEvent.EventSignature] = append(p.eventsBySignature[contractEvent.EventSignature], &contractEvent)
+	}
 
 	return &contractEvent
 }

indexer/processor/cross_domain_messenger.go

@@ -49,7 +49,7 @@ type CrossDomainMessengerRelayedMessageEvent struct {
 }
 
 func CrossDomainMessengerSentMessageEvents(events *ProcessedContractEvents) ([]CrossDomainMessengerSentMessageEvent, error) {
-	crossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
+	crossDomainMessengerABI, err := bindings.CrossDomainMessengerMetaData.GetAbi()
 	if err != nil {
 		return nil, err
 	}
@@ -60,16 +60,18 @@ func CrossDomainMessengerSentMessageEvents(events *ProcessedContractEvents) ([]C
 	processedSentMessageEvents := events.eventsBySignature[sentMessageEventAbi.ID]
 	crossDomainMessageEvents := make([]CrossDomainMessengerSentMessageEvent, len(processedSentMessageEvents))
 	for i, sentMessageEvent := range processedSentMessageEvents {
-		log := events.eventLog[sentMessageEvent.GUID]
+		log := sentMessageEvent.GethLog
 
 		var sentMsgData bindings.CrossDomainMessengerSentMessage
+		sentMsgData.Raw = *log
 		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]
+		extensionLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GethLog
+		sentMsgExtensionData.Raw = *extensionLog
 		err = UnpackLog(&sentMsgExtensionData, extensionLog, sentMessageEventExtensionAbi.Name, crossDomainMessengerABI)
 		if err != nil {
 			return nil, err
@@ -101,15 +103,19 @@ func CrossDomainMessengerRelayedMessageEvents(events *ProcessedContractEvents) (
 	processedRelayedMessageEvents := events.eventsBySignature[relayedMessageEventAbi.ID]
 	crossDomainMessageEvents := make([]CrossDomainMessengerRelayedMessageEvent, len(processedRelayedMessageEvents))
 	for i, relayedMessageEvent := range processedRelayedMessageEvents {
-		log := events.eventLog[relayedMessageEvent.GUID]
+		log := relayedMessageEvent.GethLog
 
 		var relayedMsgData bindings.CrossDomainMessengerRelayedMessage
+		relayedMsgData.Raw = *log
 		err = UnpackLog(&relayedMsgData, log, relayedMessageEventAbi.Name, crossDomainMessengerABI)
 		if err != nil {
 			return nil, err
 		}
 
-		crossDomainMessageEvents[i] = CrossDomainMessengerRelayedMessageEvent{&relayedMsgData, relayedMessageEvent}
+		crossDomainMessageEvents[i] = CrossDomainMessengerRelayedMessageEvent{
+			CrossDomainMessengerRelayedMessage: &relayedMsgData,
+			RawEvent:                           relayedMessageEvent,
+		}
 	}
 
 	return crossDomainMessageEvents, nil

indexer/processor/l1_processor.go

@@ -399,10 +399,10 @@ func l1ProcessContractEventsBridgeCrossDomainMessages(processLog log.Logger, db
 
 	sentMessages := make([]*database.L1BridgeMessage, len(sentMessageEvents))
 	for i, sentMessageEvent := range sentMessageEvents {
-		log := events.eventLog[sentMessageEvent.RawEvent.GUID]
+		log := sentMessageEvent.RawEvent.GethLog
 
 		// extract the deposit hash from the previous TransactionDepositedEvent
-		transactionDepositedLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index - 1}].GUID]
+		transactionDepositedLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index - 1}].GethLog
 		depositTx, err := derive.UnmarshalDepositLogEvent(transactionDepositedLog)
 		if err != nil {
 			return err
@@ -479,10 +479,10 @@ func l1ProcessContractEventsStandardBridge(processLog log.Logger, db *database.D
 
 	deposits := make([]*database.L1BridgeDeposit, len(initiatedDepositEvents))
 	for i, initiatedBridgeEvent := range initiatedDepositEvents {
-		log := events.eventLog[initiatedBridgeEvent.RawEvent.GUID]
+		log := initiatedBridgeEvent.RawEvent.GethLog
 
 		// extract the deposit hash from the following TransactionDeposited event
-		transactionDepositedLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GUID]
+		transactionDepositedLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GethLog
 		depositTx, err := derive.UnmarshalDepositLogEvent(transactionDepositedLog)
 		if err != nil {
 			return err

indexer/processor/l2_processor.go

@@ -106,17 +106,8 @@ func l2ProcessFn(processLog log.Logger, ethClient node.EthClient, l2Contracts L2
 		l2Headers := make([]*database.L2BlockHeader, len(headers))
 		l2HeaderMap := make(map[common.Hash]*types.Header)
 		for i, header := range headers {
-			blockHash := header.Hash()
-			l2Headers[i] = &database.L2BlockHeader{
-				BlockHeader: database.BlockHeader{
-					Hash:       blockHash,
-					ParentHash: header.ParentHash,
-					Number:     database.U256{Int: header.Number},
-					Timestamp:  header.Time,
-				},
-			}
-
-			l2HeaderMap[blockHash] = header
+			l2Headers[i] = &database.L2BlockHeader{BlockHeader: database.BlockHeaderFromGethHeader(header)}
+			l2HeaderMap[l2Headers[i].Hash] = header
 		}
 
 		/** Watch for Contract Events **/
@@ -255,10 +246,10 @@ func l2ProcessContractEventsBridgeCrossDomainMessages(processLog log.Logger, db
 
 	sentMessages := make([]*database.L2BridgeMessage, len(sentMessageEvents))
 	for i, sentMessageEvent := range sentMessageEvents {
-		log := events.eventLog[sentMessageEvent.RawEvent.GUID]
+		log := sentMessageEvent.RawEvent.GethLog
 
 		// extract the withdrawal hash from the previous MessagePassed event
-		msgPassedLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index - 1}].GUID]
+		msgPassedLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index - 1}].GethLog
 		msgPassedEvent, err := l2ToL1MessagePasserABI.ParseMessagePassed(*msgPassedLog)
 		if err != nil {
 			return err
@@ -355,10 +346,10 @@ func l2ProcessContractEventsStandardBridge(processLog log.Logger, db *database.D
 
 	withdrawals := make([]*database.L2BridgeWithdrawal, len(initiatedWithdrawalEvents))
 	for i, initiatedBridgeEvent := range initiatedWithdrawalEvents {
-		log := events.eventLog[initiatedBridgeEvent.RawEvent.GUID]
+		log := initiatedBridgeEvent.RawEvent.GethLog
 
 		// extract the withdrawal hash from the following MessagePassed event
-		msgPassedLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GUID]
+		msgPassedLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GethLog
 		msgPassedEvent, err := l2ToL1MessagePasserABI.ParseMessagePassed(*msgPassedLog)
 		if err != nil {
 			return err

indexer/processor/l2_to_l1_message_passer.go

@@ -20,15 +20,19 @@ func L2ToL1MessagePasserMessagesPassed(events *ProcessedContractEvents) ([]L2ToL
 	processedMessagePassedEvents := events.eventsBySignature[l2ToL1MessagePasserAbi.Events[eventName].ID]
 	messagesPassed := make([]L2ToL1MessagePasserMessagePassed, len(processedMessagePassedEvents))
 	for i, messagePassedEvent := range processedMessagePassedEvents {
-		log := events.eventLog[messagePassedEvent.GUID]
+		log := messagePassedEvent.GethLog
 
 		var messagePassed bindings.L2ToL1MessagePasserMessagePassed
+		messagePassed.Raw = *log
 		err := UnpackLog(&messagePassed, log, eventName, l2ToL1MessagePasserAbi)
 		if err != nil {
 			return nil, err
 		}
 
-		messagesPassed[i] = L2ToL1MessagePasserMessagePassed{&messagePassed, messagePassedEvent}
+		messagesPassed[i] = L2ToL1MessagePasserMessagePassed{
+			L2ToL1MessagePasserMessagePassed: &messagePassed,
+			RawEvent:                         messagePassedEvent,
+		}
 	}
 
 	return messagesPassed, nil

indexer/processor/optimism_portal.go

 package processor
 
 import (
-	"context"
 	"errors"
 	"math/big"
 
@@ -9,10 +8,7 @@ import (
 	"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 {
@@ -51,7 +47,7 @@ func OptimismPortalTransactionDepositEvents(events *ProcessedContractEvents) ([]
 	processedTxDepositedEvents := events.eventsBySignature[derive.DepositEventABIHash]
 	txDeposits := make([]OptimismPortalTransactionDepositEvent, len(processedTxDepositedEvents))
 	for i, txDepositEvent := range processedTxDepositedEvents {
-		log := events.eventLog[txDepositEvent.GUID]
+		log := txDepositEvent.GethLog
 
 		depositTx, err := derive.UnmarshalDepositLogEvent(log)
 		if err != nil {
@@ -59,12 +55,17 @@ func OptimismPortalTransactionDepositEvents(events *ProcessedContractEvents) ([]
 		}
 
 		var txDeposit bindings.OptimismPortalTransactionDeposited
+		txDeposit.Raw = *log
 		err = UnpackLog(&txDeposit, log, eventName, optimismPortalAbi)
 		if err != nil {
 			return nil, err
 		}
 
-		txDeposits[i] = OptimismPortalTransactionDepositEvent{&txDeposit, depositTx, txDepositEvent}
+		txDeposits[i] = OptimismPortalTransactionDepositEvent{
+			OptimismPortalTransactionDeposited: &txDeposit,
+			DepositTx:                          depositTx,
+			RawEvent:                           txDepositEvent,
+		}
 	}
 
 	return txDeposits, nil
@@ -80,15 +81,19 @@ func OptimismPortalWithdrawalProvenEvents(events *ProcessedContractEvents) ([]Op
 	processedWithdrawalProvenEvents := events.eventsBySignature[optimismPortalAbi.Events[eventName].ID]
 	provenEvents := make([]OptimismPortalWithdrawalProvenEvent, len(processedWithdrawalProvenEvents))
 	for i, provenEvent := range processedWithdrawalProvenEvents {
-		log := events.eventLog[provenEvent.GUID]
+		log := provenEvent.GethLog
 
 		var withdrawalProven bindings.OptimismPortalWithdrawalProven
+		withdrawalProven.Raw = *log
 		err := UnpackLog(&withdrawalProven, log, eventName, optimismPortalAbi)
 		if err != nil {
 			return nil, err
 		}
 
-		provenEvents[i] = OptimismPortalWithdrawalProvenEvent{&withdrawalProven, provenEvent}
+		provenEvents[i] = OptimismPortalWithdrawalProvenEvent{
+			OptimismPortalWithdrawalProven: &withdrawalProven,
+			RawEvent:                       provenEvent,
+		}
 	}
 
 	return provenEvents, nil
@@ -104,7 +109,7 @@ func OptimismPortalWithdrawalFinalizedEvents(events *ProcessedContractEvents) ([
 	processedWithdrawalFinalizedEvents := events.eventsBySignature[optimismPortalAbi.Events[eventName].ID]
 	finalizedEvents := make([]OptimismPortalWithdrawalFinalizedEvent, len(processedWithdrawalFinalizedEvents))
 	for i, finalizedEvent := range processedWithdrawalFinalizedEvents {
-		log := events.eventLog[finalizedEvent.GUID]
+		log := finalizedEvent.GethLog
 
 		var withdrawalFinalized bindings.OptimismPortalWithdrawalFinalized
 		err := UnpackLog(&withdrawalFinalized, log, eventName, optimismPortalAbi)
@@ -112,36 +117,11 @@ func OptimismPortalWithdrawalFinalizedEvents(events *ProcessedContractEvents) ([
 			return nil, err
 		}
 
-		finalizedEvents[i] = OptimismPortalWithdrawalFinalizedEvent{&withdrawalFinalized, finalizedEvent}
+		finalizedEvents[i] = OptimismPortalWithdrawalFinalizedEvent{
+			OptimismPortalWithdrawalFinalized: &withdrawalFinalized,
+			RawEvent:                          finalizedEvent,
+		}
 	}
 
 	return finalizedEvents, nil
 }
-
-func OptimismPortalQueryProvenWithdrawal(ethClient *ethclient.Client, portalAddress common.Address, withdrawalHash common.Hash) (OptimismPortalProvenWithdrawal, error) {
-	var provenWithdrawal OptimismPortalProvenWithdrawal
-
-	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
-	if err != nil {
-		return provenWithdrawal, err
-	}
-
-	name := "provenWithdrawals"
-	txData, err := optimismPortalAbi.Pack(name, withdrawalHash)
-	if err != nil {
-		return provenWithdrawal, err
-	}
-
-	callMsg := ethereum.CallMsg{To: &portalAddress, Data: txData}
-	data, err := ethClient.CallContract(context.Background(), callMsg, nil)
-	if err != nil {
-		return provenWithdrawal, err
-	}
-
-	err = optimismPortalAbi.UnpackIntoInterface(&provenWithdrawal, name, data)
-	if err != nil {
-		return provenWithdrawal, err
-	}
-
-	return provenWithdrawal, nil
-}

indexer/processor/standard_bridge.go

@@ -97,7 +97,7 @@ func _standardBridgeInitiatedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 	processedInitiatedBridgeEvents := events.eventsBySignature[StandardBridgeABI.Events[eventName].ID]
 	initiatedBridgeEvents := make([]StandardBridgeInitiatedEvent, len(processedInitiatedBridgeEvents))
 	for i, bridgeInitiatedEvent := range processedInitiatedBridgeEvents {
-		log := events.eventLog[bridgeInitiatedEvent.GUID]
+		log := bridgeInitiatedEvent.GethLog
 
 		var bridgeData BridgeEvent
 		err := UnpackLog(&bridgeData, log, eventName, StandardBridgeABI)
@@ -109,7 +109,8 @@ func _standardBridgeInitiatedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 		//   - L1: BridgeInitiated -> Portal#DepositTransaction -> SentMessage ...
 		//   - L1: BridgeInitiated -> L2ToL1MessagePasser#MessagePassed -> SentMessage ...
 		var sentMsgData bindings.L1CrossDomainMessengerSentMessage
-		sentMsgLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 2}].GUID]
+		sentMsgLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 2}].GethLog
+		sentMsgData.Raw = *sentMsgLog
 		err = UnpackLog(&sentMsgData, sentMsgLog, sentMessageEventAbi.Name, l1CrossDomainMessengerABI)
 		if err != nil {
 			return nil, err
@@ -127,6 +128,7 @@ func _standardBridgeInitiatedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 
 			// represent eth bridge as an erc20
 			erc20BridgeData = &bindings.StandardBridgeERC20BridgeInitiated{
+				Raw: *log,
 				// Represent ETH using the hardcoded address
 				LocalToken: predeploys.LegacyERC20ETHAddr, RemoteToken: predeploys.LegacyERC20ETHAddr,
 				// Bridge data
@@ -136,6 +138,7 @@ func _standardBridgeInitiatedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 		case bindings.StandardBridgeERC20BridgeInitiated:
 			_temp := any(bridgeData).(bindings.StandardBridgeERC20BridgeInitiated)
 			erc20BridgeData = &_temp
+			erc20BridgeData.Raw = *log
 			expectedCrossDomainMessage, err = StandardBridgeABI.Pack(finalizeMethodName, erc20BridgeData.RemoteToken, erc20BridgeData.LocalToken, erc20BridgeData.From, erc20BridgeData.To, erc20BridgeData.Amount, erc20BridgeData.ExtraData)
 			if err != nil {
 				return nil, err
@@ -146,7 +149,11 @@ func _standardBridgeInitiatedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 			return nil, errors.New("bridge cross domain message mismatch")
 		}
 
-		initiatedBridgeEvents[i] = StandardBridgeInitiatedEvent{erc20BridgeData, sentMsgData.MessageNonce, bridgeInitiatedEvent}
+		initiatedBridgeEvents[i] = StandardBridgeInitiatedEvent{
+			StandardBridgeERC20BridgeInitiated: erc20BridgeData,
+			CrossDomainMessengerNonce:          sentMsgData.MessageNonce,
+			RawEvent:                           bridgeInitiatedEvent,
+		}
 	}
 
 	return initiatedBridgeEvents, nil
@@ -190,7 +197,7 @@ func _standardBridgeFinalizedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 	processedFinalizedBridgeEvents := events.eventsBySignature[StandardBridgeABI.Events[eventName].ID]
 	finalizedBridgeEvents := make([]StandardBridgeFinalizedEvent, len(processedFinalizedBridgeEvents))
 	for i, bridgeFinalizedEvent := range processedFinalizedBridgeEvents {
-		log := events.eventLog[bridgeFinalizedEvent.GUID]
+		log := bridgeFinalizedEvent.GethLog
 
 		var bridgeData BridgeEvent
 		err := UnpackLog(&bridgeData, log, eventName, StandardBridgeABI)
@@ -199,7 +206,7 @@ func _standardBridgeFinalizedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 		}
 
 		// Look for the RelayedMessage event that follows right after the BridgeFinalized Event
-		relayedMsgLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GUID]
+		relayedMsgLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GethLog
 		if relayedMsgLog.Topics[0] != relayedMessageEventAbi.ID {
 			return nil, errors.New("unexpected bridge event ordering")
 		}
@@ -257,6 +264,7 @@ func _standardBridgeFinalizedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 		case bindings.StandardBridgeETHBridgeFinalized:
 			ethBridgeData := any(bridgeData).(bindings.StandardBridgeETHBridgeFinalized)
 			erc20BridgeData = &bindings.StandardBridgeERC20BridgeFinalized{
+				Raw: *log,
 				// Represent ETH using the hardcoded address
 				LocalToken: predeploys.LegacyERC20ETHAddr, RemoteToken: predeploys.LegacyERC20ETHAddr,
 				// Bridge data
@@ -266,9 +274,14 @@ func _standardBridgeFinalizedEvents[BridgeEvent bindings.StandardBridgeETHBridge
 		case bindings.StandardBridgeERC20BridgeFinalized:
 			_temp := any(bridgeData).(bindings.StandardBridgeERC20BridgeFinalized)
 			erc20BridgeData = &_temp
+			erc20BridgeData.Raw = *log
 		}
 
-		finalizedBridgeEvents[i] = StandardBridgeFinalizedEvent{erc20BridgeData, nonce, bridgeFinalizedEvent}
+		finalizedBridgeEvents[i] = StandardBridgeFinalizedEvent{
+			StandardBridgeERC20BridgeFinalized: erc20BridgeData,
+			CrossDomainMessengerNonce:          nonce,
+			RawEvent:                           bridgeFinalizedEvent,
+		}
 	}
 
 	return finalizedBridgeEvents, nil