preemptively hard code crossdomainmessenger addrs. Handle OptimismPortal...

preemptively hard code crossdomainmessenger addrs. Handle OptimismPortal finalization when parsing the nonce

indexer/processor/l1_processor.go

@@ -308,15 +308,16 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		// Check if the L2Processor is behind or really has missed an event. We can compare against the
 		// OptimismPortal#ProvenWithdrawal on-chain mapping relative to the latest indexed L2 height
 		if withdrawal == nil {
-			bridgeAddress := l1Contracts.L1StandardBridge
-			portalAddress := l1Contracts.OptimismPortal
-			if provenWithdrawalEvent.From != bridgeAddress || provenWithdrawalEvent.To != bridgeAddress {
+
+			// This needs to be updated to read from config as well as correctly identify if the CrossDomainMessenger message is a standard
+			// bridge message. This will easier to do once we index passed messages seperately which will include the right To/From fields
+			if provenWithdrawalEvent.From != common.HexToAddress("0x4200000000000000000000000000000000000007") || provenWithdrawalEvent.To != l1Contracts.L1CrossDomainMessenger {
 				// non-bridge withdrawal
 				continue
 			}
 
 			// Query for the the proven withdrawal on-chain
-			provenWithdrawal, err := OptimismPortalQueryProvenWithdrawal(rawEthClient, portalAddress, withdrawalHash)
+			provenWithdrawal, err := OptimismPortalQueryProvenWithdrawal(rawEthClient, l1Contracts.OptimismPortal, withdrawalHash)
 			if err != nil {
 				return err
 			}
@@ -361,8 +362,8 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 			return err
 		}
 
-		// Since we have to prove the event on-chain first, we don't need to check if the processor is
-		// behind. we're definitely in an error state if we cannot find the withdrawal when parsing this even
+		// Since we have to prove the event on-chain first, we don't need to check if the processor is behind
+		// We're definitely in an error state if we cannot find the withdrawal when parsing this event
 		if withdrawal == nil {
 			processLog.Crit("missing indexed withdrawal for this finalization event")
 			return errors.New("missing withdrawal message")

indexer/processor/optimism_portal.go

@@ -30,11 +30,20 @@ func OptimismPortalWithdrawalProvenEvents(events *ProcessedContractEvents) ([]Op
 		return nil, err
 	}
 
-	processedWithdrawalProvenEvents := events.eventsBySignature[optimismPortalAbi.Events["WithdrawalProven"].ID]
+	eventName := "WithdrawalProven"
+
+	processedWithdrawalProvenEvents := events.eventsBySignature[optimismPortalAbi.Events[eventName].ID]
 	provenEvents := make([]OptimismPortalWithdrawalProvenEvent, len(processedWithdrawalProvenEvents))
 	for i, provenEvent := range processedWithdrawalProvenEvents {
+		log := events.eventLog[provenEvent.GUID]
+
+		var withdrawalProven bindings.OptimismPortalWithdrawalProven
+		err := UnpackLog(&withdrawalProven, log, eventName, optimismPortalAbi)
+		if err != nil {
+			return nil, err
+		}
 
-		provenEvents[i] = OptimismPortalWithdrawalProvenEvent{nil, provenEvent}
+		provenEvents[i] = OptimismPortalWithdrawalProvenEvent{&withdrawalProven, provenEvent}
 	}
 
 	return provenEvents, nil

indexer/processor/standard_bridge.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"fmt"
 	"math/big"
 
 	"github.com/ethereum-optimism/optimism/indexer/database"
@@ -170,8 +171,14 @@ func _standardBridgeFinalizedEvents[BridgeEvent bindings.L1StandardBridgeETHBrid
 		return nil, err
 	}
 
+	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
 	relayedMessageEventAbi := l1CrossDomainMessengerABI.Events["RelayedMessage"]
 	relayMessageMethodAbi := l1CrossDomainMessengerABI.Methods["relayMessage"]
+	finalizeWithdrawalTransactionMethodAbi := optimismPortalAbi.Methods["finalizeWithdrawalTransaction"]
 
 	var bridgeData BridgeEvent
 	var eventName string
@@ -201,28 +208,46 @@ func _standardBridgeFinalizedEvents[BridgeEvent bindings.L1StandardBridgeETHBrid
 			return nil, errors.New("unexpected bridge event ordering")
 		}
 
-		// 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
+		// by unpacking the transaction input for the `relayMessage` transaction. Since bedrock has OptimismPortal
+		// as on L1 as an intermediary for finalization, we have to check both scenarios
 		tx, isPending, err := rawEthClient.TransactionByHash(context.Background(), relayedMsgLog.TxHash)
 		if err != nil || isPending {
 			return nil, errors.New("unable to query relayMessage tx for bridge finalization event")
 		}
 
-		txData := tx.Data()
-		if !bytes.Equal(txData[:4], relayMessageMethodAbi.ID) {
-			return nil, errors.New("bridge finalization event does not match relayMessage tx invocation")
-		}
-
+		// If this is a finalization step with the optimism portal, the same relay message nonce is used as the
+		// withdrawal transaction nonce. lets simply read the withdrawal message nonce and save additional decoding
+		var nonce *big.Int
+		switch {
+		case bytes.Equal(tx.Data()[:4], relayMessageMethodAbi.ID):
 			inputsMap := make(map[string]interface{})
-		err = relayMessageMethodAbi.Inputs.UnpackIntoMap(inputsMap, txData[4:])
+			err = relayMessageMethodAbi.Inputs.UnpackIntoMap(inputsMap, tx.Data()[4:])
 			if err != nil {
 				return nil, err
 			}
-
-		nonce, ok := inputsMap["_nonce"].(*big.Int)
+			_nonce, ok := inputsMap["_nonce"].(*big.Int)
 			if !ok {
 				return nil, errors.New("unable to extract `_nonce` parameter from relayMessage transaction")
 			}
+			nonce = _nonce
+		case bytes.Equal(tx.Data()[:4], finalizeWithdrawalTransactionMethodAbi.ID):
+			data, err := finalizeWithdrawalTransactionMethodAbi.Inputs.Unpack(tx.Data()[4:])
+			if err != nil {
+				return nil, err
+			}
+
+			finalizeWithdrawTransactionInput := new(struct {
+				Tx bindings.TypesWithdrawalTransaction
+			})
+			err = finalizeWithdrawalTransactionMethodAbi.Inputs.Copy(finalizeWithdrawTransactionInput, data)
+			if err != nil {
+				return nil, fmt.Errorf("unable extract withdrawal tx input from finalizeWithdrawalTransaction transaction: %w", err)
+			}
+			nonce = finalizeWithdrawTransactionInput.Tx.Nonce
+		default:
+			return nil, errors.New("bridge finalization event does not match relayMessage tx invocation")
+		}
 
 		var erc20BridgeData *bindings.L1StandardBridgeERC20BridgeFinalized
 		switch any(bridgeData).(type) {