fully utilize bindings

indexer/processor/l1_processor.go

@@ -156,6 +156,7 @@ func l1ProcessFn(processLog log.Logger, ethClient node.EthClient, l1Contracts L1
 			contractEvent := &database.L1ContractEvent{ContractEvent: database.ContractEventFromLog(&log, header.Time)}
 
 			l1ContractEvents[i] = contractEvent
+			l1ContractEventLogs[contractEvent.GUID] = &logs[i]
 			l1HeadersOfInterest[log.BlockHash] = true
 
 			// Track Checkpoint Events for L2
@@ -273,20 +274,6 @@ func l1BridgeProcessContractEvents(
 		return err
 	}
 
-	type MessageData struct {
-		Sender       common.Address
-		Message      []byte
-		MessageNonce *big.Int
-		GasLimit     *big.Int
-	}
-
-	type BridgeData struct {
-		From      common.Address
-		To        common.Address
-		Amount    *big.Int
-		ExtraData []byte
-	}
-
 	l1StandardBridgeDeposits := []*database.Deposit{}
 	ethBridgeInitiatedEventSig := l1StandardBridgeABI.Events["ETHBridgeInitiated"].ID
 	sentMessageEventSig := l1CrossDomainMessengerABI.Events["SentMessage"].ID
@@ -295,14 +282,14 @@ func l1BridgeProcessContractEvents(
 		log := eventLogs[contractEvent.GUID]
 		if eventSig == ethBridgeInitiatedEventSig {
 			// (1) Deconstruct the bridge event
-			var bridgeData BridgeData
+			var bridgeData bindings.L1StandardBridgeETHBridgeInitiated
 			err = l1StandardBridgeABI.UnpackIntoInterface(&bridgeData, "ETHBridgeInitiated", log.Data)
 			if err != nil || len(log.Topics) != 3 {
 				processLog.Crit("unexpected ETHDepositInitiated log format", "tx", log.TxHash, "err", err)
 				return err
 			}
 
-			// from/to are indexed event fields (not present in the log data)
+			// from/to must be retrieved from log topics
 			bridgeData.From = common.BytesToAddress(log.Topics[1].Bytes())
 			bridgeData.To = common.BytesToAddress(log.Topics[2].Bytes())
 
@@ -320,13 +307,13 @@ func l1BridgeProcessContractEvents(
 				return err
 			}
 
-			var sentMsgData MessageData
-			err = l1CrossDomainMessengerABI.UnpackIntoInterface(&sentMsgData, "SentMessage", sentMsgLog.Data)
+			var sentMsg bindings.L1CrossDomainMessengerSentMessage
+			err = l1CrossDomainMessengerABI.UnpackIntoInterface(&sentMsg, "SentMessage", sentMsgLog.Data)
 			if err != nil {
 				processLog.Crit("unexpected SentMessage log format", "tx", log.TxHash, "err", err)
 				return err
-			} else if !bytes.Equal(sentMsgData.Message, expectedMsg) {
-				processLog.Crit("SentMessage message mismatch", "expected_bridge_msg", hex.EncodeToString(expectedMsg), "event_msg", hex.EncodeToString(sentMsgData.Message))
+			} else if !bytes.Equal(sentMsg.Message, expectedMsg) {
+				processLog.Crit("SentMessage message mismatch", "expected_bridge_msg", hex.EncodeToString(expectedMsg), "event_msg", hex.EncodeToString(sentMsg.Message))
 				return errors.New("bridge message mismatch")
 			}
 
@@ -334,7 +321,7 @@ func l1BridgeProcessContractEvents(
 			l1StandardBridgeDeposits = append(l1StandardBridgeDeposits, &database.Deposit{
 				GUID:                 uuid.New(),
 				InitiatedL1EventGUID: contractEvent.GUID,
-				SentMessageNonce:     database.U256{Int: sentMsgData.MessageNonce},
+				SentMessageNonce:     database.U256{Int: sentMsg.MessageNonce},
 				TokenPair:            database.TokenPair{L1TokenAddress: ethAddress, L2TokenAddress: ethAddress},
 				Tx: database.Transaction{
 					FromAddress: common.BytesToAddress(log.Topics[1].Bytes()),

indexer/processor/l2_processor.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
@@ -193,13 +194,6 @@ func l2BridgeProcessContractEvents(
 		return err
 	}
 
-	type BridgeData struct {
-		From      common.Address
-		To        common.Address
-		Amount    *big.Int
-		ExtraData []byte
-	}
-
 	numFinalizedDeposits := 0
 	ethBridgeFinalizedEventSig := l2StandardBridgeABI.Events["ETHBridgeFinalized"].ID
 	relayedMessageEventSig := l2CrossDomainMessengerABI.Events["RelayedMessage"].ID
@@ -215,8 +209,8 @@ func l2BridgeProcessContractEvents(
 				return errors.New("unexpected bridge event ordering")
 			}
 
-			// unfortunately there's no way to extract the nonce on the relayed message event. we can
-			// extract the nonce by unpacking the transaction input for the `relayMessage` transaction
+			// There's no way to extract the nonce on the relayed message event. we can extract
+			// the nonce by unpacking the transaction input for the `relayMessage` transaction
 			tx, isPending, err := rawEthClient.TransactionByHash(context.Background(), relayedMsgLog.TxHash)
 			if err != nil || isPending {
 				processLog.Crit("CrossDomainMessager#relayeMessage transaction query err or found pending", err, "err", "isPending", isPending)
@@ -224,15 +218,13 @@ func l2BridgeProcessContractEvents(
 			}
 
 			txData := tx.Data()
-			fnSelector := txData[:4]
-			if !bytes.Equal(fnSelector, relayMessageMethod.ID) {
+			if !bytes.Equal(txData[:4], relayMessageMethod.ID) {
 				processLog.Crit("expected relayMessage function selector")
 				return errors.New("RelayMessage log does not match relayMessage transaction")
 			}
 
-			fnData := txData[4:]
 			inputsMap := make(map[string]interface{})
-			err = relayMessageMethod.Inputs.UnpackIntoMap(inputsMap, fnData)
+			err = relayMessageMethod.Inputs.UnpackIntoMap(inputsMap, txData[4:])
 			if err != nil {
 				processLog.Crit("unable to unpack CrossDomainMessenger#relayMessage function data", "err", err)
 				return err
@@ -255,12 +247,13 @@ func l2BridgeProcessContractEvents(
 					return err
 				}
 
-				// check if the the L1Processor is behind or really has missed an event
+				// Check if the L1Processor is behind or really has missed an event. Since the decimal representation
+				// of the nonce will be large (first two bytes indicate the version), we log the nonce as needed in hex format
 				if latestNonce == nil || nonce.Cmp(latestNonce) > 0 {
-					processLog.Warn("behind on indexed L1 deposits", "deposit_message_nonce", nonce, "latest_deposit_message_nonce", latestNonce)
+					processLog.Warn("behind on indexed L1 deposits", "deposit_message_nonce", hexutil.EncodeBig(nonce), "latest_deposit_message_nonce", hexutil.EncodeBig(latestNonce))
 					return errors.New("waiting for L1Processor to catch up")
 				} else {
-					processLog.Crit("missing indexed deposit for this finalization event", "deposit_message_nonce", nonce, "tx_hash", log.TxHash, "log_index", log.Index)
+					processLog.Crit("missing indexed deposit for this finalization event", "deposit_message_nonce", hexutil.EncodeBig(nonce), "tx_hash", log.TxHash, "log_index", log.Index)
 					return errors.New("missing deposit message")
 				}
 			}