Merge branch 'develop' into inphi/update-ci-builder

.changeset/bright-mayflies-jog.md

+---
+'@eth-optimism/sdk': patch
+---
+
+Fixed missing indexes for multicall support

cannon/mipsevm/evm.go

@@ -24,7 +24,7 @@ import (
 )
 
 var (
-	StepBytes4                      = crypto.Keccak256([]byte("Step(bytes,bytes)"))[:4]
+	StepBytes4                      = crypto.Keccak256([]byte("step(bytes,bytes)"))[:4]
 	CheatBytes4                     = crypto.Keccak256([]byte("cheat(uint256,bytes32,bytes32,uint256)"))[:4]
 	LoadKeccak256PreimagePartBytes4 = crypto.Keccak256([]byte("loadKeccak256PreimagePart(uint256,bytes)"))[:4]
 )

indexer/api/api_test.go

 package api
 
 import (
+	"math/big"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -25,7 +26,7 @@ func (mbv *MockBridgeView) DepositsByAddress(address common.Address) ([]*databas
 		{
 			Deposit: database.Deposit{
 				GUID:                 uuid.MustParse(guid1),
-				InitiatedL1EventGUID: guid2,
+				InitiatedL1EventGUID: uuid.MustParse(guid2),
 				Tx:                   database.Transaction{},
 				TokenPair:            database.TokenPair{},
 			},
@@ -34,13 +35,28 @@ func (mbv *MockBridgeView) DepositsByAddress(address common.Address) ([]*databas
 	}, nil
 }
 
+// DepositsByAddress mocks returning deposits by an address
+func (mbv *MockBridgeView) DepositByMessageNonce(nonce *big.Int) (*database.Deposit, error) {
+	return &database.Deposit{
+		GUID:                 uuid.MustParse(guid1),
+		InitiatedL1EventGUID: uuid.MustParse(guid2),
+		Tx:                   database.Transaction{},
+		TokenPair:            database.TokenPair{},
+	}, nil
+}
+
+// LatestDepositMessageNonce mocks returning the latest cross domain message nonce for a deposit
+func (mbv *MockBridgeView) LatestDepositMessageNonce() (*big.Int, error) {
+	return big.NewInt(0), nil
+}
+
 // WithdrawalsByAddress mocks returning withdrawals by an address
 func (mbv *MockBridgeView) WithdrawalsByAddress(address common.Address) ([]*database.WithdrawalWithTransactionHashes, error) {
 	return []*database.WithdrawalWithTransactionHashes{
 		{
 			Withdrawal: database.Withdrawal{
 				GUID:                 uuid.MustParse(guid2),
-				InitiatedL2EventGUID: guid1,
+				InitiatedL2EventGUID: uuid.MustParse(guid1),
 				WithdrawalHash:       common.HexToHash("0x456"),
 				Tx:                   database.Transaction{},
 				TokenPair:            database.TokenPair{},
@@ -50,6 +66,33 @@ func (mbv *MockBridgeView) WithdrawalsByAddress(address common.Address) ([]*data
 	}, nil
 }
 
+// WithdrawalsByMessageNonce mocks returning withdrawals by a withdrawal hash
+func (mbv *MockBridgeView) WithdrawalByMessageNonce(nonce *big.Int) (*database.Withdrawal, error) {
+	return &database.Withdrawal{
+		GUID:                 uuid.MustParse(guid2),
+		InitiatedL2EventGUID: uuid.MustParse(guid1),
+		WithdrawalHash:       common.HexToHash("0x456"),
+		Tx:                   database.Transaction{},
+		TokenPair:            database.TokenPair{},
+	}, nil
+}
+
+// WithdrawalsByHash mocks returning withdrawals by a withdrawal hash
+func (mbv *MockBridgeView) WithdrawalByHash(address common.Hash) (*database.Withdrawal, error) {
+	return &database.Withdrawal{
+		GUID:                 uuid.MustParse(guid2),
+		InitiatedL2EventGUID: uuid.MustParse(guid1),
+		WithdrawalHash:       common.HexToHash("0x456"),
+		Tx:                   database.Transaction{},
+		TokenPair:            database.TokenPair{},
+	}, nil
+}
+
+// LatestWithdrawalMessageNonce mocks returning the latest cross domain message nonce for a withdrawal
+func (mbv *MockBridgeView) LatestWithdrawalMessageNonce() (*big.Int, error) {
+	return big.NewInt(0), nil
+}
+
 func TestHealthz(t *testing.T) {
 	api := NewApi(&MockBridgeView{})
 	request, err := http.NewRequest("GET", "/healthz", nil)

indexer/database/blocks.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+
 	"github.com/google/uuid"
 
 	"gorm.io/gorm"
@@ -21,6 +23,15 @@ type BlockHeader struct {
 	Timestamp  uint64
 }
 
+func BlockHeaderFromGethHeader(header *types.Header) BlockHeader {
+	return BlockHeader{
+		Hash:       header.Hash(),
+		ParentHash: header.ParentHash,
+		Number:     U256{Int: header.Number},
+		Timestamp:  header.Time,
+	}
+}
+
 type L1BlockHeader struct {
 	BlockHeader
 }
@@ -41,8 +52,9 @@ type LegacyStateBatch struct {
 }
 
 type OutputProposal struct {
-	OutputRoot          common.Hash `gorm:"primaryKey;serializer:json"`
-	L2BlockNumber       U256
+	OutputRoot    common.Hash `gorm:"primaryKey;serializer:json"`
+	L2BlockNumber U256
+
 	L1ContractEventGUID uuid.UUID
 }
 

indexer/database/bridge.go

@@ -2,6 +2,8 @@ package database
 
 import (
 	"errors"
+	"fmt"
+	"math/big"
 
 	"gorm.io/gorm"
 
@@ -30,7 +32,17 @@ type TokenPair struct {
 
 type Deposit struct {
 	GUID                 uuid.UUID `gorm:"primaryKey"`
-	InitiatedL1EventGUID string
+	InitiatedL1EventGUID uuid.UUID
+
+	// Since we're only currently indexing a single StandardBridge,
+	// the message nonce serves as a unique identifier for this
+	// deposit. Once this generalizes to more than 1 deployed
+	// bridge, we need to include the `CrossDomainMessenger` address
+	// such that the (messenger_addr, nonce) is the unique identifier
+	// for a bridge msg
+	SentMessageNonce U256
+
+	FinalizedL2EventGUID *uuid.UUID
 
 	Tx        Transaction `gorm:"embedded"`
 	TokenPair TokenPair   `gorm:"embedded"`
@@ -43,11 +55,19 @@ type DepositWithTransactionHash struct {
 
 type Withdrawal struct {
 	GUID                 uuid.UUID `gorm:"primaryKey"`
-	InitiatedL2EventGUID string
+	InitiatedL2EventGUID uuid.UUID
+
+	// Since we're only currently indexing a single StandardBridge,
+	// the message nonce serves as a unique identifier for this
+	// withdrawal. Once this generalizes to more than 1 deployed
+	// bridge, we need to include the `CrossDomainMessenger` address
+	// such that the (messenger_addr, nonce) is the unique identifier
+	// for a bridge msg
+	SentMessageNonce U256
 
 	WithdrawalHash       common.Hash `gorm:"serializer:json"`
-	ProvenL1EventGUID    *string
-	FinalizedL1EventGUID *string
+	ProvenL1EventGUID    *uuid.UUID
+	FinalizedL1EventGUID *uuid.UUID
 
 	Tx        Transaction `gorm:"embedded"`
 	TokenPair TokenPair   `gorm:"embedded"`
@@ -63,16 +83,24 @@ type WithdrawalWithTransactionHashes struct {
 
 type BridgeView interface {
 	DepositsByAddress(address common.Address) ([]*DepositWithTransactionHash, error)
+	DepositByMessageNonce(*big.Int) (*Deposit, error)
+	LatestDepositMessageNonce() (*big.Int, error)
+
 	WithdrawalsByAddress(address common.Address) ([]*WithdrawalWithTransactionHashes, error)
+	WithdrawalByMessageNonce(*big.Int) (*Withdrawal, error)
+	WithdrawalByHash(common.Hash) (*Withdrawal, error)
+	LatestWithdrawalMessageNonce() (*big.Int, error)
 }
 
 type BridgeDB interface {
 	BridgeView
 
 	StoreDeposits([]*Deposit) error
+	MarkFinalizedDepositEvent(uuid.UUID, uuid.UUID) error
+
 	StoreWithdrawals([]*Withdrawal) error
-	MarkProvenWithdrawalEvent(string, string) error
-	MarkFinalizedWithdrawalEvent(string, string) error
+	MarkProvenWithdrawalEvent(uuid.UUID, uuid.UUID) error
+	MarkFinalizedWithdrawalEvent(uuid.UUID, uuid.UUID) error
 }
 
 /**
@@ -114,6 +142,46 @@ func (db *bridgeDB) DepositsByAddress(address common.Address) ([]*DepositWithTra
 	return deposits, nil
 }
 
+func (db *bridgeDB) DepositByMessageNonce(nonce *big.Int) (*Deposit, error) {
+	var deposit Deposit
+	result := db.gorm.First(&deposit, "sent_message_nonce = ?", U256{Int: nonce})
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return &deposit, nil
+}
+
+func (db *bridgeDB) LatestDepositMessageNonce() (*big.Int, error) {
+	var deposit Deposit
+	result := db.gorm.Order("sent_message_nonce DESC").Take(&deposit)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return deposit.SentMessageNonce.Int, nil
+}
+
+func (db *bridgeDB) MarkFinalizedDepositEvent(guid, finalizationEventGUID uuid.UUID) error {
+	var deposit Deposit
+	result := db.gorm.First(&deposit, "guid = ?", guid)
+	if result.Error != nil {
+		return result.Error
+	}
+
+	deposit.FinalizedL2EventGUID = &finalizationEventGUID
+	result = db.gorm.Save(&deposit)
+	return result.Error
+}
+
 // Withdrawals
 
 func (db *bridgeDB) StoreWithdrawals(withdrawals []*Withdrawal) error {
@@ -121,7 +189,7 @@ func (db *bridgeDB) StoreWithdrawals(withdrawals []*Withdrawal) error {
 	return result.Error
 }
 
-func (db *bridgeDB) MarkProvenWithdrawalEvent(guid, provenL1EventGuid string) error {
+func (db *bridgeDB) MarkProvenWithdrawalEvent(guid, provenL1EventGuid uuid.UUID) error {
 	var withdrawal Withdrawal
 	result := db.gorm.First(&withdrawal, "guid = ?", guid)
 	if result.Error != nil {
@@ -133,13 +201,17 @@ func (db *bridgeDB) MarkProvenWithdrawalEvent(guid, provenL1EventGuid string) er
 	return result.Error
 }
 
-func (db *bridgeDB) MarkFinalizedWithdrawalEvent(guid, finalizedL1EventGuid string) error {
+func (db *bridgeDB) MarkFinalizedWithdrawalEvent(guid, finalizedL1EventGuid uuid.UUID) error {
 	var withdrawal Withdrawal
 	result := db.gorm.First(&withdrawal, "guid = ?", guid)
 	if result.Error != nil {
 		return result.Error
 	}
 
+	if withdrawal.ProvenL1EventGUID == nil {
+		return fmt.Errorf("withdrawal %s marked finalized prior to being proven", guid)
+	}
+
 	withdrawal.FinalizedL1EventGUID = &finalizedL1EventGuid
 	result = db.gorm.Save(&withdrawal)
 	return result.Error
@@ -167,3 +239,45 @@ func (db *bridgeDB) WithdrawalsByAddress(address common.Address) ([]*WithdrawalW
 
 	return withdrawals, nil
 }
+
+func (db *bridgeDB) WithdrawalByMessageNonce(nonce *big.Int) (*Withdrawal, error) {
+	var withdrawal Withdrawal
+	result := db.gorm.First(&withdrawal, "sent_message_nonce = ?", U256{Int: nonce})
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return &withdrawal, nil
+}
+
+func (db *bridgeDB) WithdrawalByHash(hash common.Hash) (*Withdrawal, error) {
+	var withdrawal Withdrawal
+	result := db.gorm.First(&withdrawal, "withdrawal_hash = ?", hash.String())
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return &withdrawal, nil
+}
+
+func (db *bridgeDB) LatestWithdrawalMessageNonce() (*big.Int, error) {
+	var withdrawal Withdrawal
+	result := db.gorm.Order("sent_message_nonce DESC").Take(&withdrawal)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+
+		return nil, result.Error
+	}
+
+	return withdrawal.SentMessageNonce.Int, nil
+}

indexer/database/contract_events.go

@@ -4,6 +4,7 @@ import (
 	"gorm.io/gorm"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 
 	"github.com/google/uuid"
 )
@@ -22,6 +23,20 @@ type ContractEvent struct {
 	Timestamp      uint64
 }
 
+func ContractEventFromGethLog(log *types.Log, timestamp uint64) ContractEvent {
+	return ContractEvent{
+		GUID: uuid.New(),
+
+		BlockHash:       log.BlockHash,
+		TransactionHash: log.TxHash,
+
+		EventSignature: log.Topics[0],
+		LogIndex:       uint64(log.Index),
+
+		Timestamp: timestamp,
+	}
+}
+
 type L1ContractEvent struct {
 	ContractEvent `gorm:"embedded"`
 }

indexer/migrations/20230523_create_schema.sql

@@ -10,14 +10,15 @@ CREATE TABLE IF NOT EXISTS l1_block_headers (
 	hash        VARCHAR NOT NULL PRIMARY KEY,
 	parent_hash VARCHAR NOT NULL,
 	number      UINT256,
-	timestamp   INTEGER NOT NULL
+	timestamp   INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 CREATE TABLE IF NOT EXISTS l2_block_headers (
-	hash        VARCHAR NOT NULL PRIMARY KEY,
-	parent_hash VARCHAR NOT NULL,
-	number      UINT256,
-	timestamp   INTEGER NOT NULL
+    -- Block header
+	hash                     VARCHAR NOT NULL PRIMARY KEY,
+	parent_hash              VARCHAR NOT NULL,
+	number                   UINT256,
+	timestamp                INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 /** 
@@ -30,7 +31,7 @@ CREATE TABLE IF NOT EXISTS l1_contract_events (
     transaction_hash VARCHAR NOT NULL,
     event_signature  VARCHAR NOT NULL,
     log_index        INTEGER NOT NULL,
-    timestamp        INTEGER NOT NULL
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 CREATE TABLE IF NOT EXISTS l2_contract_events (
@@ -39,7 +40,7 @@ CREATE TABLE IF NOT EXISTS l2_contract_events (
     transaction_hash VARCHAR NOT NULL,
     event_signature  VARCHAR NOT NULL,
     log_index        INTEGER NOT NULL,
-    timestamp        INTEGER NOT NULL
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 -- Tables that index finalization markers for L2 blocks.
@@ -69,6 +70,10 @@ CREATE TABLE IF NOT EXISTS deposits (
 
     -- Event causing the deposit
     initiated_l1_event_guid VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
+    sent_message_nonce      UINT256 UNIQUE,
+
+    -- Finalization marker for the deposit
+    finalized_l2_event_guid VARCHAR REFERENCES l2_contract_events(guid),
 
     -- Deposit information (do we need indexes on from/to?)
 	from_address     VARCHAR NOT NULL,
@@ -78,7 +83,7 @@ CREATE TABLE IF NOT EXISTS deposits (
 	l2_token_address VARCHAR NOT NULL,
 	amount           UINT256,
 	data             VARCHAR NOT NULL,
-    timestamp        INTEGER NOT NULL
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
 CREATE TABLE IF NOT EXISTS withdrawals (
@@ -86,6 +91,7 @@ CREATE TABLE IF NOT EXISTS withdrawals (
 
     -- Event causing this withdrawal
     initiated_l2_event_guid VARCHAR NOT NULL REFERENCES l2_contract_events(guid),
+    sent_message_nonce      UINT256 UNIQUE,
 
     -- Multistep (bedrock) process of a withdrawal
     withdrawal_hash      VARCHAR NOT NULL,
@@ -101,5 +107,5 @@ CREATE TABLE IF NOT EXISTS withdrawals (
 	l2_token_address VARCHAR NOT NULL,
 	amount           UINT256,
 	data             VARCHAR NOT NULL,
-    timestamp        INTEGER NOT NULL
+    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );

indexer/processor/contract_events.go

+package processor
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+
+	"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
+}
+
+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 {
+	return &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)
+
+	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
+
+	return &contractEvent
+}
+
+func UnpackLog(out interface{}, log *types.Log, name string, contractAbi *abi.ABI) error {
+	eventAbi, ok := contractAbi.Events[name]
+	if !ok {
+		return fmt.Errorf("event %s not present in supplied ABI", name)
+	} else if len(log.Topics) == 0 {
+		return errors.New("anonymous events are not supported")
+	} else if log.Topics[0] != eventAbi.ID {
+		return errors.New("event signature mismatch")
+	}
+
+	err := contractAbi.UnpackIntoInterface(out, name, log.Data)
+	if err != nil {
+		return err
+	}
+
+	// handle topics if present
+	if len(log.Topics) > 1 {
+		var indexedArgs abi.Arguments
+		for _, arg := range eventAbi.Inputs {
+			if arg.Indexed {
+				indexedArgs = append(indexedArgs, arg)
+			}
+		}
+
+		// The first topic (event signature) is omitted
+		err := abi.ParseTopics(out, indexedArgs, log.Topics[1:])
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

indexer/processor/l2_processor.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/indexer/node"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/google/uuid"
 
 	"github.com/ethereum/go-ethereum"
@@ -124,8 +125,8 @@ func l2ProcessFn(processLog log.Logger, ethClient node.EthClient, l2Contracts L2
 			return err
 		}
 
-		numLogs := len(logs)
-		l2ContractEvents := make([]*database.L2ContractEvent, numLogs)
+		l2ContractEvents := make([]*database.L2ContractEvent, len(logs))
+		processedContractEvents := NewProcessedContractEvents()
 		for i, log := range logs {
 			header, ok := l2HeaderMap[log.BlockHash]
 			if !ok {
@@ -133,16 +134,8 @@ func l2ProcessFn(processLog log.Logger, ethClient node.EthClient, l2Contracts L2
 				return errors.New("parsed log with a block hash not in this batch")
 			}
 
-			l2ContractEvents[i] = &database.L2ContractEvent{
-				ContractEvent: database.ContractEvent{
-					GUID:            uuid.New(),
-					BlockHash:       log.BlockHash,
-					TransactionHash: log.TxHash,
-					EventSignature:  log.Topics[0],
-					LogIndex:        uint64(log.Index),
-					Timestamp:       header.Time,
-				},
-			}
+			contractEvent := processedContractEvents.AddLog(&logs[i], header.Time)
+			l2ContractEvents[i] = &database.L2ContractEvent{ContractEvent: *contractEvent}
 		}
 
 		/** Update Database **/
@@ -153,15 +146,118 @@ func l2ProcessFn(processLog log.Logger, ethClient node.EthClient, l2Contracts L2
 			return err
 		}
 
+		numLogs := len(l2ContractEvents)
 		if numLogs > 0 {
 			processLog.Info("detected contract logs", "size", numLogs)
 			err = db.ContractEvents.StoreL2ContractEvents(l2ContractEvents)
 			if err != nil {
 				return err
 			}
+
+			// forward along contract events to the bridge processor
+			err = l2BridgeProcessContractEvents(processLog, db, ethClient, processedContractEvents)
+			if err != nil {
+				return err
+			}
 		}
 
 		// a-ok!
 		return nil
 	}
 }
+
+func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethClient node.EthClient, events *ProcessedContractEvents) error {
+	rawEthClient := ethclient.NewClient(ethClient.RawRpcClient())
+
+	l2ToL1MessagePasserABI, err := bindings.L2ToL1MessagePasserMetaData.GetAbi()
+	if err != nil {
+		return err
+	}
+
+	messagePassedEventAbi := l2ToL1MessagePasserABI.Events["MessagePassed"]
+
+	// Process New Withdrawals
+	initiatedWithdrawalEvents, err := StandardBridgeInitiatedEvents(events)
+	if err != nil {
+		return err
+	}
+
+	withdrawals := make([]*database.Withdrawal, len(initiatedWithdrawalEvents))
+	for i, initiatedBridgeEvent := range initiatedWithdrawalEvents {
+		log := events.eventLog[initiatedBridgeEvent.RawEvent.GUID]
+
+		// extract the withdrawal hash from the MessagePassed event
+		var msgPassedData bindings.L2ToL1MessagePasserMessagePassed
+		msgPassedLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GUID]
+		err := UnpackLog(&msgPassedData, msgPassedLog, messagePassedEventAbi.Name, l2ToL1MessagePasserABI)
+		if err != nil {
+			return err
+		}
+
+		withdrawals[i] = &database.Withdrawal{
+			GUID:                 uuid.New(),
+			InitiatedL2EventGUID: initiatedBridgeEvent.RawEvent.GUID,
+			SentMessageNonce:     database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
+			WithdrawalHash:       msgPassedData.WithdrawalHash,
+			TokenPair:            database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
+			Tx: database.Transaction{
+				FromAddress: initiatedBridgeEvent.From,
+				ToAddress:   initiatedBridgeEvent.To,
+				Amount:      database.U256{Int: initiatedBridgeEvent.Amount},
+				Data:        initiatedBridgeEvent.ExtraData,
+				Timestamp:   initiatedBridgeEvent.RawEvent.Timestamp,
+			},
+		}
+	}
+
+	if len(withdrawals) > 0 {
+		processLog.Info("detected L2StandardBridge withdrawals", "num", len(withdrawals))
+		err := db.Bridge.StoreWithdrawals(withdrawals)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Finalize Deposits
+	finalizationBridgeEvents, err := StandardBridgeFinalizedEvents(rawEthClient, events)
+	if err != nil {
+		return err
+	}
+
+	for _, finalizedBridgeEvent := range finalizationBridgeEvents {
+		nonce := finalizedBridgeEvent.CrossDomainMessengerNonce
+
+		deposit, err := db.Bridge.DepositByMessageNonce(nonce)
+		if err != nil {
+			processLog.Error("error querying associated deposit messsage using nonce", "cross_domain_messenger_nonce", nonce)
+			return err
+		} else if deposit == nil {
+			latestNonce, err := db.Bridge.LatestDepositMessageNonce()
+			if err != nil {
+				return err
+			}
+
+			// Check if the L1Processor is behind or really has missed an event
+			if latestNonce == nil || nonce.Cmp(latestNonce) > 0 {
+				processLog.Warn("behind on indexed L1 deposits")
+				return errors.New("waiting for L1Processor to catch up")
+			} else {
+				processLog.Crit("missing indexed deposit for this finalization event")
+				return errors.New("missing deposit message")
+			}
+		}
+
+		err = db.Bridge.MarkFinalizedDepositEvent(deposit.GUID, finalizedBridgeEvent.RawEvent.GUID)
+		if err != nil {
+			processLog.Error("error finalizing deposit", "err", err)
+			return err
+		}
+	}
+
+	if len(finalizationBridgeEvents) > 0 {
+		processLog.Info("finalized L1StandardBridge deposits", "size", len(finalizationBridgeEvents))
+	}
+
+	// a-ok
+	return nil
+}

indexer/processor/optimism_portal.go

+package processor
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+type OptimismPortalWithdrawalProvenEvent struct {
+	*bindings.OptimismPortalWithdrawalProven
+
+	RawEvent *database.ContractEvent
+}
+
+type OptimismPortalProvenWithdrawal struct {
+	OutputRoot    [32]byte
+	Timestamp     *big.Int
+	L2OutputIndex *big.Int
+}
+
+func OptimismPortalWithdrawalProvenEvents(events *ProcessedContractEvents) ([]OptimismPortalWithdrawalProvenEvent, error) {
+	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	processedWithdrawalProvenEvents := events.eventsBySignature[optimismPortalAbi.Events["WithdrawalProven"].ID]
+	provenEvents := make([]OptimismPortalWithdrawalProvenEvent, len(processedWithdrawalProvenEvents))
+	for i, provenEvent := range processedWithdrawalProvenEvents {
+
+		provenEvents[i] = OptimismPortalWithdrawalProvenEvent{nil, provenEvent}
+	}
+
+	return provenEvents, 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/processor.go

@@ -55,8 +55,8 @@ func (p processor) Start() {
 		firstHeader := unprocessedHeaders[0]
 		lastHeader := unprocessedHeaders[len(unprocessedHeaders)-1]
 		batchLog := p.processLog.New("batch_start_block_number", firstHeader.Number, "batch_end_block_number", lastHeader.Number)
-		batchLog.Info("processing batch")
 		err := p.db.Transaction(func(db *database.DB) error {
+			batchLog.Info("processing batch")
 			return p.processFn(db, unprocessedHeaders)
 		})
 

indexer/processor/standard_bridge.go

+package processor
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+var (
+	ethAddress = common.HexToAddress("0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000")
+)
+
+type StandardBridgeInitiatedEvent struct {
+	// We hardcode to ERC20 since ETH can be pseudo-represented as an ERC20 utilizing
+	// the hardcoded ETH address
+	*bindings.L1StandardBridgeERC20BridgeInitiated
+
+	CrossDomainMessengerNonce *big.Int
+	RawEvent                  *database.ContractEvent
+}
+
+type StandardBridgeFinalizedEvent struct {
+	// We hardcode to ERC20 since ETH can be pseudo-represented as an ERC20 utilizing
+	// the hardcoded ETH address
+	*bindings.L1StandardBridgeERC20BridgeFinalized
+
+	CrossDomainMessengerNonce *big.Int
+	RawEvent                  *database.ContractEvent
+}
+
+// StandardBridgeInitiatedEvents extracts all initiated bridge events from the contracts that follow the StandardBridge ABI. The
+// correlated CrossDomainMessenger nonce is also parsed from the associated messenger events.
+func StandardBridgeInitiatedEvents(events *ProcessedContractEvents) ([]StandardBridgeInitiatedEvent, error) {
+	ethBridgeInitiatedEvents, err := _standardBridgeInitiatedEvents[bindings.L1StandardBridgeETHBridgeInitiated](events)
+	if err != nil {
+		return nil, err
+	}
+
+	erc20BridgeInitiatedEvents, err := _standardBridgeInitiatedEvents[bindings.L1StandardBridgeERC20BridgeInitiated](events)
+	if err != nil {
+		return nil, err
+	}
+
+	return append(ethBridgeInitiatedEvents, erc20BridgeInitiatedEvents...), nil
+}
+
+// StandardBridgeFinalizedEvents extracts all finalization bridge events from the contracts that follow the StandardBridge ABI. The
+// correlated CrossDomainMessenger nonce is also parsed by looking at the parameters of the corresponding relayMessage transaction data.
+func StandardBridgeFinalizedEvents(rawEthClient *ethclient.Client, events *ProcessedContractEvents) ([]StandardBridgeFinalizedEvent, error) {
+	ethBridgeFinalizedEvents, err := _standardBridgeFinalizedEvents[bindings.L1StandardBridgeETHBridgeFinalized](rawEthClient, events)
+	if err != nil {
+		return nil, err
+	}
+
+	erc20BridgeFinalizedEvents, err := _standardBridgeFinalizedEvents[bindings.L1StandardBridgeERC20BridgeFinalized](rawEthClient, events)
+	if err != nil {
+		return nil, err
+	}
+
+	return append(ethBridgeFinalizedEvents, erc20BridgeFinalizedEvents...), nil
+}
+
+// parse out eth or erc20 bridge initiated events
+func _standardBridgeInitiatedEvents[BridgeEvent bindings.L1StandardBridgeETHBridgeInitiated | bindings.L1StandardBridgeERC20BridgeInitiated](
+	events *ProcessedContractEvents,
+) ([]StandardBridgeInitiatedEvent, error) {
+	l1StandardBridgeABI, err := bindings.L1StandardBridgeMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	l1CrossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	sentMessageEventAbi := l1CrossDomainMessengerABI.Events["SentMessage"]
+
+	var tmp BridgeEvent
+	var eventName string
+	var finalizeMethodName string
+	switch any(tmp).(type) {
+	case bindings.L1StandardBridgeETHBridgeInitiated:
+		eventName = "ETHBridgeInitiated"
+		finalizeMethodName = "finalizeBridgeETH"
+	case bindings.L1StandardBridgeERC20BridgeInitiated:
+		eventName = "ERC20BridgeInitiated"
+		finalizeMethodName = "finalizeBridgeERC20"
+	default:
+		panic("should not be here")
+	}
+
+	processedInitiatedBridgeEvents := events.eventsBySignature[l1StandardBridgeABI.Events[eventName].ID]
+	initiatedBridgeEvents := make([]StandardBridgeInitiatedEvent, len(processedInitiatedBridgeEvents))
+	for i, bridgeInitiatedEvent := range processedInitiatedBridgeEvents {
+		log := events.eventLog[bridgeInitiatedEvent.GUID]
+
+		bridgeData := new(BridgeEvent)
+		err := UnpackLog(bridgeData, log, eventName, l1StandardBridgeABI)
+		if err != nil {
+			return nil, err
+		}
+
+		// Look for the sent message event to extract the associated messager nonce
+		//   - 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]
+		err = UnpackLog(&sentMsgData, sentMsgLog, sentMessageEventAbi.Name, l1CrossDomainMessengerABI)
+		if err != nil {
+			return nil, err
+		}
+
+		var erc20BridgeData *bindings.L1StandardBridgeERC20BridgeInitiated
+		var expectedCrossDomainMessage []byte
+		switch any(bridgeData).(type) {
+		case *bindings.L1StandardBridgeETHBridgeInitiated:
+			ethBridgeData := any(bridgeData).(*bindings.L1StandardBridgeETHBridgeInitiated)
+			expectedCrossDomainMessage, err = l1StandardBridgeABI.Pack(finalizeMethodName, ethBridgeData.From, ethBridgeData.To, ethBridgeData.Amount, ethBridgeData.ExtraData)
+			if err != nil {
+				return nil, err
+			}
+
+			// represent eth bridge as an erc20
+			erc20BridgeData = &bindings.L1StandardBridgeERC20BridgeInitiated{
+				// Represent ETH using the hardcoded address
+				LocalToken: ethAddress, RemoteToken: ethAddress,
+				// Bridge data
+				From: ethBridgeData.From, To: ethBridgeData.To, Amount: ethBridgeData.Amount, ExtraData: ethBridgeData.ExtraData,
+			}
+
+		case *bindings.L1StandardBridgeERC20BridgeInitiated:
+			_temp := any(bridgeData).(bindings.L1StandardBridgeERC20BridgeInitiated)
+			erc20BridgeData = &_temp
+			expectedCrossDomainMessage, err = l1StandardBridgeABI.Pack(finalizeMethodName, erc20BridgeData.RemoteToken, erc20BridgeData.LocalToken, erc20BridgeData.From, erc20BridgeData.To, erc20BridgeData.Amount, erc20BridgeData.ExtraData)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		if !bytes.Equal(sentMsgData.Message, expectedCrossDomainMessage) {
+			return nil, errors.New("bridge cross domain message mismatch")
+		}
+
+		initiatedBridgeEvents[i] = StandardBridgeInitiatedEvent{erc20BridgeData, sentMsgData.MessageNonce, bridgeInitiatedEvent}
+	}
+
+	return initiatedBridgeEvents, nil
+}
+
+// parse out eth or erc20 bridge finalization events
+func _standardBridgeFinalizedEvents[BridgeEvent bindings.L1StandardBridgeETHBridgeFinalized | bindings.L1StandardBridgeERC20BridgeFinalized](
+	rawEthClient *ethclient.Client,
+	events *ProcessedContractEvents,
+) ([]StandardBridgeFinalizedEvent, error) {
+	l1StandardBridgeABI, err := bindings.L1StandardBridgeMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	l1CrossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	relayedMessageEventAbi := l1CrossDomainMessengerABI.Events["RelayedMessage"]
+	relayMessageMethodAbi := l1CrossDomainMessengerABI.Methods["relayMessage"]
+
+	var bridgeData BridgeEvent
+	var eventName string
+	switch any(bridgeData).(type) {
+	case bindings.L1StandardBridgeETHBridgeFinalized:
+		eventName = "ETHBridgeFinalized"
+	case bindings.L1StandardBridgeERC20BridgeFinalized:
+		eventName = "ERC20BridgeFinalized"
+	default:
+		panic("should not be here")
+	}
+
+	processedFinalizedBridgeEvents := events.eventsBySignature[l1StandardBridgeABI.Events[eventName].ID]
+	finalizedBridgeEvents := make([]StandardBridgeFinalizedEvent, len(processedFinalizedBridgeEvents))
+	for i, bridgeFinalizedEvent := range processedFinalizedBridgeEvents {
+		log := events.eventLog[bridgeFinalizedEvent.GUID]
+
+		var bridgeData BridgeEvent
+		err := UnpackLog(&bridgeData, log, eventName, l1StandardBridgeABI)
+		if err != nil {
+			return nil, err
+		}
+
+		// Look for the RelayedMessage event that follows right after the BridgeFinalized Event
+		relayedMsgLog := events.eventLog[events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].GUID]
+		if relayedMsgLog.Topics[0] != relayedMessageEventAbi.ID {
+			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
+		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")
+		}
+
+		inputsMap := make(map[string]interface{})
+		err = relayMessageMethodAbi.Inputs.UnpackIntoMap(inputsMap, txData[4:])
+		if err != nil {
+			return nil, err
+		}
+
+		nonce, ok := inputsMap["_nonce"].(*big.Int)
+		if !ok {
+			return nil, errors.New("unable to extract `_nonce` parameter from relayMessage transaction")
+		}
+
+		var erc20BridgeData *bindings.L1StandardBridgeERC20BridgeFinalized
+		switch any(bridgeData).(type) {
+		case bindings.L1StandardBridgeETHBridgeInitiated:
+			ethBridgeData := any(bridgeData).(bindings.L1StandardBridgeETHBridgeFinalized)
+			erc20BridgeData = &bindings.L1StandardBridgeERC20BridgeFinalized{
+				// Represent ETH using the hardcoded address
+				LocalToken: ethAddress, RemoteToken: ethAddress,
+				// Bridge data
+				From: ethBridgeData.From, To: ethBridgeData.To, Amount: ethBridgeData.Amount, ExtraData: ethBridgeData.ExtraData,
+			}
+
+		case bindings.L1StandardBridgeERC20BridgeInitiated:
+			_temp := any(bridgeData).(bindings.L1StandardBridgeERC20BridgeFinalized)
+			erc20BridgeData = &_temp
+		}
+
+		finalizedBridgeEvents[i] = StandardBridgeFinalizedEvent{erc20BridgeData, nonce, bridgeFinalizedEvent}
+	}
+
+	return finalizedBridgeEvents, nil
+}

nx.json

@@ -4,7 +4,10 @@
     "defaultBase": "develop"
   },
   "implicitDependencies": {
-    "nx.json": "*"
+    "nx.json": "*",
+    "tsconfig.json": "*",
+    ".foundryrc": "*",
+    ".nvmrc": "*"
   },
   "tasksRunnerOptions": {
     "default": {

op-challenger/fault/abi_test.go

+package fault
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/stretchr/testify/require"
+)
+
+// setupFaultDisputeGame deploys the FaultDisputeGame contract to a simulated backend
+func setupFaultDisputeGame() (common.Address, *bind.TransactOpts, *backends.SimulatedBackend, *bindings.FaultDisputeGame, error) {
+	privateKey, err := crypto.GenerateKey()
+	from := crypto.PubkeyToAddress(privateKey.PublicKey)
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	opts, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	backend := backends.NewSimulatedBackend(core.GenesisAlloc{from: {Balance: big.NewInt(params.Ether)}}, 50_000_000)
+	_, _, contract, err := bindings.DeployFaultDisputeGame(
+		opts,
+		backend,
+		[32]byte{0x01},
+		big.NewInt(15),
+		common.Address{0xdd},
+	)
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	return from, opts, backend, contract, nil
+}
+
+// TestBuildFaultDefendData ensures that the manual ABI packing is the same as going through the bound contract.
+func TestBuildFaultDefendData(t *testing.T) {
+	_, opts, _, contract, err := setupFaultDisputeGame()
+	require.NoError(t, err)
+
+	responder, _ := newTestFaultResponder(t, false)
+
+	data, err := responder.buildFaultDefendData(1, [32]byte{0x02, 0x03})
+	require.NoError(t, err)
+
+	opts.GasLimit = 100_000
+	tx, err := contract.Defend(opts, big.NewInt(1), [32]byte{0x02, 0x03})
+	require.NoError(t, err)
+
+	require.Equal(t, data, tx.Data())
+}
+
+// TestBuildFaultAttackData ensures that the manual ABI packing is the same as going through the bound contract.
+func TestBuildFaultAttackData(t *testing.T) {
+	_, opts, _, contract, err := setupFaultDisputeGame()
+	require.NoError(t, err)
+
+	responder, _ := newTestFaultResponder(t, false)
+
+	data, err := responder.buildFaultAttackData(1, [32]byte{0x02, 0x03})
+	require.NoError(t, err)
+
+	opts.GasLimit = 100_000
+	tx, err := contract.Attack(opts, big.NewInt(1), [32]byte{0x02, 0x03})
+	require.NoError(t, err)
+
+	require.Equal(t, data, tx.Data())
+}
+
+// TestBuildFaultStepData ensures that the manual ABI packing is the same as going through the bound contract.
+func TestBuildFaultStepData(t *testing.T) {
+	_, opts, _, contract, err := setupFaultDisputeGame()
+	require.NoError(t, err)
+
+	responder, _ := newTestFaultResponder(t, false)
+
+	data, err := responder.buildStepTxData(StepCallData{
+		ClaimIndex: 2,
+		IsAttack:   false,
+		StateData:  []byte{0x01},
+		Proof:      []byte{0x02},
+	})
+	require.NoError(t, err)
+
+	opts.GasLimit = 100_000
+	tx, err := contract.Step(opts, big.NewInt(2), false, []byte{0x01}, []byte{0x02})
+	require.NoError(t, err)
+
+	require.Equal(t, data, tx.Data())
+}

op-challenger/fault/agent.go

@@ -2,53 +2,68 @@ package fault
 
 import (
 	"context"
-	"sync"
+	"errors"
 
 	"github.com/ethereum/go-ethereum/log"
 )
 
 type Agent struct {
-	mu        sync.Mutex
-	game      Game
 	solver    *Solver
 	trace     TraceProvider
+	loader    Loader
 	responder Responder
 	maxDepth  int
 	log       log.Logger
 }
 
-func NewAgent(game Game, maxDepth int, trace TraceProvider, responder Responder, log log.Logger) Agent {
+func NewAgent(loader Loader, maxDepth int, trace TraceProvider, responder Responder, log log.Logger) Agent {
 	return Agent{
-		game:      game,
 		solver:    NewSolver(maxDepth, trace),
 		trace:     trace,
+		loader:    loader,
 		responder: responder,
 		maxDepth:  maxDepth,
 		log:       log,
 	}
 }
 
-// AddClaim stores a claim in the local state.
-// This function shares a lock with PerformActions.
-func (a *Agent) AddClaim(claim Claim) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.game.Put(claim)
+// Act iterates the game & performs all of the next actions.
+func (a *Agent) Act() error {
+	game, err := a.newGameFromContracts(context.Background())
+	if err != nil {
+		a.log.Error("Failed to create new game", "err", err)
+		return err
+	}
+	// Create counter claims
+	for _, claim := range game.Claims() {
+		_ = a.move(claim, game)
+	}
+	// Step on all leaf claims
+	for _, claim := range game.Claims() {
+		_ = a.step(claim, game)
+	}
+	return nil
 }
 
-// PerformActions iterates the game & performs all of the next actions.
-// Note: PerformActions & AddClaim share a lock so the responder cannot
-// call AddClaim on the same thread.
-func (a *Agent) PerformActions() {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, claim := range a.game.Claims() {
-		_ = a.move(claim)
+// newGameFromContracts initializes a new game state from the state in the contract
+func (a *Agent) newGameFromContracts(ctx context.Context) (Game, error) {
+	claims, err := a.loader.FetchClaims(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if len(claims) == 0 {
+		return nil, errors.New("no claims")
 	}
+	game := NewGameState(claims[0], uint64(a.maxDepth))
+	if err := game.PutAll(claims[1:]); err != nil {
+		return nil, err
+	}
+	return game, nil
 }
 
 // move determines & executes the next move given a claim pair
-func (a *Agent) move(claim Claim) error {
+func (a *Agent) move(claim Claim, game Game) error {
+	a.log.Info("Fetching claims")
 	nextMove, err := a.solver.NextMove(claim)
 	if err != nil {
 		a.log.Warn("Failed to execute the next move", "err", err)
@@ -62,10 +77,33 @@ func (a *Agent) move(claim Claim) error {
 	log := a.log.New("is_defend", move.DefendsParent(), "depth", move.Depth(), "index_at_depth", move.IndexAtDepth(), "value", move.Value,
 		"letter", string(move.Value[31:]), "trace_index", move.Value[30],
 		"parent_letter", string(claim.Value[31:]), "parent_trace_index", claim.Value[30])
-	if a.game.IsDuplicate(move) {
+	if game.IsDuplicate(move) {
 		log.Debug("Duplicate move")
 		return nil
 	}
 	log.Info("Performing move")
 	return a.responder.Respond(context.TODO(), move)
 }
+
+// step attempts to execute the step through the responder
+func (a *Agent) step(claim Claim, game Game) error {
+	if claim.Depth() != a.maxDepth {
+		return nil
+	}
+	a.log.Info("Attempting step", "claim_depth", claim.Depth(), "maxDepth", a.maxDepth)
+
+	step, err := a.solver.AttemptStep(claim)
+	if err != nil {
+		a.log.Info("Failed to get a step", "err", err)
+		return err
+	}
+
+	a.log.Info("Performing step",
+		"depth", step.LeafClaim.Depth(), "index_at_depth", step.LeafClaim.IndexAtDepth(), "value", step.LeafClaim.Value,
+		"is_attack", step.IsAttack)
+	callData := StepCallData{
+		ClaimIndex: uint64(step.LeafClaim.ContractIndex),
+		IsAttack:   step.IsAttack,
+	}
+	return a.responder.Step(context.TODO(), callData)
+}

op-challenger/fault/orchestrator.go

@@ -2,74 +2,74 @@ package fault
 
 import (
 	"context"
-	"os"
-	"time"
 
 	"github.com/ethereum/go-ethereum/log"
 )
 
 type Orchestrator struct {
-	agents    []Agent
-	outputChs []chan Claim
-	responses chan Claim
+	agents []Agent
+	claims []Claim
+	steps  []StepCallData
+
+	// tracking when to exit
+	claimLen, stepLen, step int
 }
 
 func NewOrchestrator(maxDepth uint64, traces []TraceProvider, names []string, root Claim) Orchestrator {
 	o := Orchestrator{
-		responses: make(chan Claim, 100),
-		outputChs: make([]chan Claim, len(traces)),
-		agents:    make([]Agent, len(traces)),
+		agents: make([]Agent, len(traces)),
+		claims: []Claim{root},
+		steps:  make([]StepCallData, 0),
 	}
 	log.Info("Starting game", "root_letter", string(root.Value[31:]))
 	for i, trace := range traces {
-		game := NewGameState(root, maxDepth)
-		o.agents[i] = NewAgent(game, int(maxDepth), trace, &o, log.New("role", names[i]))
-		o.outputChs[i] = make(chan Claim)
+		o.agents[i] = NewAgent(&o, int(maxDepth), trace, &o, log.New("role", names[i]))
 	}
 	return o
 }
 
 func (o *Orchestrator) Respond(_ context.Context, response Claim) error {
-	o.responses <- response
+	response.ContractIndex = len(o.claims)
+	o.claims = append(o.claims, response)
 	return nil
 }
 
-func (o *Orchestrator) Step(ctx context.Context, stepData StepCallData) error {
+func (o *Orchestrator) Step(_ context.Context, stepData StepCallData) error {
+	log.Info("Step recorded", "step", stepData)
+	o.steps = append(o.steps, stepData)
 	return nil
 }
 
-func (o *Orchestrator) Start() {
-	for i := 0; i < len(o.agents); i++ {
-		go runAgent(&o.agents[i], o.outputChs[i])
-	}
-	o.responderThread()
+func (o *Orchestrator) FetchClaims(ctx context.Context) ([]Claim, error) {
+	c := make([]Claim, len(o.claims))
+	copy(c, o.claims)
+	return c, nil
 }
 
-func runAgent(agent *Agent, claimCh <-chan Claim) {
+func (o *Orchestrator) Start() {
 	for {
-		agent.PerformActions()
-		// Note: Should drain the channel here
-		claim := <-claimCh
-		_ = agent.AddClaim(claim)
-
+		for _, a := range o.agents {
+			_ = a.Act()
+		}
+		if o.shouldExit() {
+			log.Info("exiting")
+			return
+		}
 	}
 }
 
-func (o *Orchestrator) responderThread() {
-	timer := time.NewTimer(200 * time.Millisecond)
-	defer timer.Stop()
-	for {
-		select {
-		case resp := <-o.responses:
-			timer.Reset(200 * time.Millisecond)
-			for _, ch := range o.outputChs {
-				// Copy it. Should be immutable, but be sure.
-				resp := resp
-				ch <- resp
-			}
-		case <-timer.C:
-			os.Exit(0)
-		}
+func (o *Orchestrator) shouldExit() bool {
+	cl := o.claimLen
+	sl := o.stepLen
+
+	o.claimLen = len(o.claims)
+	o.stepLen = len(o.steps)
 
+	noProgress := o.claimLen == cl && o.stepLen == sl
+	if noProgress {
+		o.step = o.step + 1
+	} else {
+		o.step = 0
 	}
+	return noProgress && o.step == 1
 }

op-challenger/fault/responder.go

@@ -104,7 +104,6 @@ func (r *faultResponder) sendTxAndWait(ctx context.Context, txData []byte) error
 func (r *faultResponder) buildStepTxData(stepData StepCallData) ([]byte, error) {
 	return r.fdgAbi.Pack(
 		"step",
-		big.NewInt(int64(stepData.StateIndex)),
 		big.NewInt(int64(stepData.ClaimIndex)),
 		stepData.IsAttack,
 		stepData.StateData,

op-challenger/fault/solver.go

@@ -31,14 +31,13 @@ func (s *Solver) NextMove(claim Claim) (*Claim, error) {
 }
 
 type StepData struct {
-	LeafClaim  Claim
-	StateClaim Claim
-	IsAttack   bool
+	LeafClaim Claim
+	IsAttack  bool
 }
 
 // AttemptStep determines what step should occur for a given leaf claim.
 // An error will be returned if the claim is not at the max depth.
-func (s *Solver) AttemptStep(claim Claim, state Game) (StepData, error) {
+func (s *Solver) AttemptStep(claim Claim) (StepData, error) {
 	if claim.Depth() != s.gameDepth {
 		return StepData{}, errors.New("cannot step on non-leaf claims")
 	}
@@ -46,20 +45,9 @@ func (s *Solver) AttemptStep(claim Claim, state Game) (StepData, error) {
 	if err != nil {
 		return StepData{}, err
 	}
-	var selectorFn func(Claim) (Claim, error)
-	if claimCorrect {
-		selectorFn = state.PostStateClaim
-	} else {
-		selectorFn = state.PreStateClaim
-	}
-	stateClaim, err := selectorFn(claim)
-	if err != nil {
-		return StepData{}, err
-	}
 	return StepData{
-		LeafClaim:  claim,
-		StateClaim: stateClaim,
-		IsAttack:   claimCorrect,
+		LeafClaim: claim,
+		IsAttack:  claimCorrect,
 	}, nil
 }
 

op-challenger/fault/solver_test.go

@@ -89,12 +89,11 @@ func TestAttemptStep(t *testing.T) {
 	require.NoError(t, g.Put(middle))
 	require.NoError(t, g.Put(bottom))
 
-	step, err := solver.AttemptStep(bottom, g)
+	step, err := solver.AttemptStep(bottom)
 	require.NoError(t, err)
 	require.Equal(t, bottom, step.LeafClaim)
-	require.Equal(t, middle, step.StateClaim)
 	require.True(t, step.IsAttack)
 
-	_, err = solver.AttemptStep(middle, g)
+	_, err = solver.AttemptStep(middle)
 	require.Error(t, err)
 }

op-challenger/fault/types.go

@@ -14,7 +14,6 @@ var (
 
 // StepCallData encapsulates the data needed to perform a step.
 type StepCallData struct {
-	StateIndex uint64
 	ClaimIndex uint64
 	IsAttack   bool
 	StateData  []byte

op-node/p2p/app_params.go

@@ -38,11 +38,11 @@ func LightApplicationScoreParams(cfg *rollup.Config) ApplicationScoreParams {
 		ValidResponseWeight: 0.5,
 		ValidResponseDecay:  ScoreDecay(tenEpochs, slot),
 
-		// Takes 20 error responses to reach the default ban threshold of -100
-		// But at most we track 10. These errors include not supporting p2p sync
-		// so we don't (yet) want to ban a peer based on this measure alone.
-		ErrorResponseCap:    10,
-		ErrorResponseWeight: -5,
+		// Takes 10 error responses to reach the default gossip threshold of -10
+		// But at most we track 9. These errors include not supporting p2p sync
+		// so we don't (yet) want to ignore gossip from a peer based on this measure alone.
+		ErrorResponseCap:    9,
+		ErrorResponseWeight: -1,
 		ErrorResponseDecay:  ScoreDecay(tenEpochs, slot),
 
 		// Takes 5 rejected payloads to reach the default ban threshold of -100

op-node/rollup/derive/pipeline.go

@@ -15,7 +15,7 @@ type Metrics interface {
 	RecordL1Ref(name string, ref eth.L1BlockRef)
 	RecordL2Ref(name string, ref eth.L2BlockRef)
 	RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID)
-	RecordChannelInputBytes(inputCompresedBytes int)
+	RecordChannelInputBytes(inputCompressedBytes int)
 }
 
 type L1Fetcher interface {

op-node/rollup/driver/driver.go

@@ -21,7 +21,7 @@ type Metrics interface {
 
 	RecordL1Ref(name string, ref eth.L1BlockRef)
 	RecordL2Ref(name string, ref eth.L2BlockRef)
-	RecordChannelInputBytes(inputCompresedBytes int)
+	RecordChannelInputBytes(inputCompressedBytes int)
 
 	RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID)
 

op-node/testutils/metrics.go

@@ -11,7 +11,7 @@ type TestDerivationMetrics struct {
 	FnRecordL1Ref             func(name string, ref eth.L1BlockRef)
 	FnRecordL2Ref             func(name string, ref eth.L2BlockRef)
 	FnRecordUnsafePayloads    func(length uint64, memSize uint64, next eth.BlockID)
-	FnRecordChannelInputBytes func(inputCompresedBytes int)
+	FnRecordChannelInputBytes func(inputCompressedBytes int)
 }
 
 func (t *TestDerivationMetrics) RecordL1ReorgDepth(d uint64) {
@@ -38,9 +38,9 @@ func (t *TestDerivationMetrics) RecordUnsafePayloadsBuffer(length uint64, memSiz
 	}
 }
 
-func (t *TestDerivationMetrics) RecordChannelInputBytes(inputCompresedBytes int) {
+func (t *TestDerivationMetrics) RecordChannelInputBytes(inputCompressedBytes int) {
 	if t.FnRecordChannelInputBytes != nil {
-		t.FnRecordChannelInputBytes(inputCompresedBytes)
+		t.FnRecordChannelInputBytes(inputCompressedBytes)
 	}
 }
 

package.json

@@ -64,6 +64,7 @@
     "patch-package": "^6.4.7",
     "prettier": "^2.8.0",
     "prettier-plugin-solidity": "^1.0.0-beta.13",
+    "rimraf": "^5.0.1",
     "ts-mocha": "^10.0.0",
     "typescript": "^4.9.3"
   },

packages/chain-mon/src/wallet-mon/service.ts

@@ -7,7 +7,7 @@ import {
   waitForProvider,
 } from '@eth-optimism/common-ts'
 import { getChainId, compareAddrs } from '@eth-optimism/core-utils'
-import { Provider } from '@ethersproject/abstract-provider'
+import { Provider, TransactionResponse } from '@ethersproject/abstract-provider'
 import mainnetConfig from '@eth-optimism/contracts-bedrock/deploy-config/mainnet.json'
 import goerliConfig from '@eth-optimism/contracts-bedrock/deploy-config/goerli.json'
 import l2OutputOracleArtifactsMainnet from '@eth-optimism/contracts-bedrock/deployments/mainnet/L2OutputOracleProxy.json'
@@ -101,7 +101,7 @@ export class WalletMonService extends BaseServiceV2<
         unexpectedCalls: {
           type: Counter,
           desc: 'Number of unexpected wallets',
-          labels: ['wallet', 'target', 'nickname'],
+          labels: ['wallet', 'target', 'nickname', 'transactionHash'],
         },
         unexpectedRpcErrors: {
           type: Counter,
@@ -150,7 +150,7 @@ export class WalletMonService extends BaseServiceV2<
       number: block.number,
     })
 
-    const transactions = []
+    const transactions: TransactionResponse[] = []
     for (const txHash of block.transactions) {
       const t = await this.options.rpc.getTransaction(txHash)
       transactions.push(t)
@@ -175,11 +175,13 @@ export class WalletMonService extends BaseServiceV2<
               nickname: account.label,
               wallet: account.address,
               target: transaction.to,
+              transactionHash: transaction.hash,
             })
             this.logger.error('Unexpected call detected', {
               nickname: account.label,
               address: account.address,
               target: transaction.to,
+              transactionHash: transaction.hash,
             })
           }
         }

packages/contracts-bedrock/contracts/cannon/MIPS.sol

@@ -379,7 +379,7 @@ contract MIPS {
   }
 
   // will revert if any required input state is missing
-  function Step(bytes calldata stateData, bytes calldata proof) public returns (bytes32) {
+  function step(bytes calldata stateData, bytes calldata proof) public returns (bytes32) {
     State memory state;
     // packed data is ~6 times smaller
     assembly {

packages/contracts-bedrock/package.json

@@ -48,7 +48,6 @@
     "@typescript-eslint/parser": "^5.60.1",
     "ds-test": "github:dapphub/ds-test#c9ce3f25bde29fc5eb9901842bf02850dfd2d084",
     "forge-std": "github:foundry-rs/forge-std#e8a047e3f40f13fa37af6fe14e6e06283d9a060e",
-    "glob": "^7.1.6",
     "solhint": "^3.4.1",
     "solhint-plugin-prettier": "^0.0.5",
     "ts-node": "^10.9.1",

packages/contracts-bedrock/scripts/forge-test-names.ts

 import fs from 'fs'
-
-import { glob } from 'glob'
+import path from 'path'
+import { execSync } from 'child_process'
 
 /**
  * Series of function name checks.
@@ -59,27 +59,67 @@ const checks: Array<{
  * Script for checking that all test functions are named correctly.
  */
 const main = async () => {
+  const result = execSync('forge config --json')
+  const config = JSON.parse(result.toString())
+  const out = config.out || 'out'
+
+  const paths = []
+
+  const readFilesRecursively = (dir: string) => {
+    const files = fs.readdirSync(dir)
+
+    for (const file of files) {
+      const filePath = path.join(dir, file)
+      const fileStat = fs.statSync(filePath)
+
+      if (fileStat.isDirectory()) {
+        readFilesRecursively(filePath)
+      } else {
+        paths.push(filePath)
+      }
+    }
+  }
+
+  readFilesRecursively(out)
+
+  console.log('Success:')
   const errors: string[] = []
-  const files = glob.sync('./forge-artifacts/**/*.t.sol/*Test*.json')
-  for (const file of files) {
-    const artifact = JSON.parse(fs.readFileSync(file, 'utf8'))
+
+  for (const filepath of paths) {
+    const artifact = JSON.parse(fs.readFileSync(filepath, 'utf8'))
+
+    let isTest = false
     for (const element of artifact.abi) {
-      // Skip non-functions and functions that don't start with "test".
-      if (element.type !== 'function' || !element.name.startsWith('test')) {
-        continue
+      if (element.name === 'IS_TEST') {
+        isTest = true
+        break
       }
+    }
+
+    if (isTest) {
+      let success = true
+      for (const element of artifact.abi) {
+        // Skip non-functions and functions that don't start with "test".
+        if (element.type !== 'function' || !element.name.startsWith('test')) {
+          continue
+        }
 
-      // Check the rest.
-      for (const { check, error } of checks) {
-        if (!check(element.name.split('_'))) {
-          errors.push(`in ${file} function ${element.name}: ${error}`)
+        // Check the rest.
+        for (const { check, error } of checks) {
+          if (!check(element.name.split('_'))) {
+            errors.push(`${filepath} function ${element.name}: ${error}`)
+            success = false
+          }
         }
       }
+      if (success) {
+        console.log(` - ${path.parse(filepath).name}`)
+      }
     }
   }
 
   if (errors.length > 0) {
-    console.error(...errors)
+    console.error(errors.join('\n'))
     process.exit(1)
   }
 }

packages/sdk/src/cross-chain-messenger.ts

@@ -1563,9 +1563,17 @@ export class CrossChainMessenger {
     opts?: {
       signer?: Signer
       overrides?: Overrides
-    }
+    },
+    /**
+     * The index of the withdrawal if multiple are made with multicall
+     */
+    messageIndex: number = 0
   ): Promise<TransactionResponse> {
-    const tx = await this.populateTransaction.proveMessage(message, opts)
+    const tx = await this.populateTransaction.proveMessage(
+      message,
+      opts,
+      messageIndex
+    )
     return (opts?.signer || this.l1Signer).sendTransaction(tx)
   }
 
@@ -1584,10 +1592,18 @@ export class CrossChainMessenger {
     opts?: {
       signer?: Signer
       overrides?: PayableOverrides
-    }
+    },
+    /**
+     * The index of the withdrawal if multiple are made with multicall
+     */
+    messageIndex = 0
   ): Promise<TransactionResponse> {
     return (opts?.signer || this.l1Signer).sendTransaction(
-      await this.populateTransaction.finalizeMessage(message, opts)
+      await this.populateTransaction.finalizeMessage(
+        message,
+        opts,
+        messageIndex
+      )
     )
   }
 
@@ -1810,7 +1826,6 @@ export class CrossChainMessenger {
       opts?: {
         overrides?: Overrides
       },
-
       /**
        * The index of the withdrawal if multiple are made with multicall
        */
@@ -1822,13 +1837,17 @@ export class CrossChainMessenger {
       }
 
       if (this.bedrock) {
-        return this.populateTransaction.finalizeMessage(resolved, {
-          ...(opts || {}),
-          overrides: {
-            ...opts?.overrides,
-            gasLimit: messageGasLimit,
+        return this.populateTransaction.finalizeMessage(
+          resolved,
+          {
+            ...(opts || {}),
+            overrides: {
+              ...opts?.overrides,
+              gasLimit: messageGasLimit,
+            },
           },
-        })
+          messageIndex
+        )
       } else {
         const legacyL1XDM = new ethers.Contract(
           this.contracts.l1.L1CrossDomainMessenger.address,
@@ -1861,7 +1880,6 @@ export class CrossChainMessenger {
       opts?: {
         overrides?: PayableOverrides
       },
-
       /**
        * The index of the withdrawal if multiple are made with multicall
        */
@@ -1921,7 +1939,6 @@ export class CrossChainMessenger {
       opts?: {
         overrides?: PayableOverrides
       },
-
       /**
        * The index of the withdrawal if multiple are made with multicall
        */
@@ -2229,10 +2246,18 @@ export class CrossChainMessenger {
       message: MessageLike,
       opts?: {
         overrides?: CallOverrides
-      }
+      },
+      /**
+       * The index of the withdrawal if multiple are made with multicall
+       */
+      messageIndex = 0
     ): Promise<BigNumber> => {
       return this.l1Provider.estimateGas(
-        await this.populateTransaction.finalizeMessage(message, opts)
+        await this.populateTransaction.finalizeMessage(
+          message,
+          opts,
+          messageIndex
+        )
       )
     },
 

pnpm-lock.yaml

@@ -123,6 +123,9 @@ importers:
       prettier-plugin-solidity:
         specifier: ^1.0.0-beta.13
         version: 1.0.0-beta.18(prettier@2.8.1)
+      rimraf:
+        specifier: ^5.0.1
+        version: 5.0.1
       ts-mocha:
         specifier: ^10.0.0
         version: 10.0.0(mocha@8.4.0)
@@ -277,9 +280,6 @@ importers:
       forge-std:
         specifier: github:foundry-rs/forge-std#e8a047e3f40f13fa37af6fe14e6e06283d9a060e
         version: github.com/foundry-rs/forge-std/e8a047e3f40f13fa37af6fe14e6e06283d9a060e
-      glob:
-        specifier: ^7.1.6
-        version: 7.1.6
       solhint:
         specifier: ^3.4.1
         version: 3.4.1
@@ -9836,7 +9836,7 @@ packages:
       fs.realpath: 1.0.0
       minimatch: 8.0.4
       minipass: 4.2.8
-      path-scurry: 1.9.2
+      path-scurry: 1.10.0
     dev: true
 
   /global-modules@2.0.0:
@@ -12152,11 +12152,6 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /lru-cache@9.1.2:
-    resolution: {integrity: sha512-ERJq3FOzJTxBbFjZ7iDs+NiK4VI9Wz+RdrrAB8dio1oV+YvdPzUEE4QNiT2VD51DkIbCYRUUzCRkssXCHqSnKQ==}
-    engines: {node: 14 || >=16.14}
-    dev: true
-
   /lru_map@0.3.3:
     resolution: {integrity: sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==}
 
@@ -14534,14 +14529,6 @@ packages:
       minipass: 6.0.2
     dev: true
 
-  /path-scurry@1.9.2:
-    resolution: {integrity: sha512-qSDLy2aGFPm8i4rsbHd4MNyTcrzHFsLQykrtbuGRknZZCBBVXSv2tSCDN2Cg6Rt/GFRw8GoW9y9Ecw5rIPG1sg==}
-    engines: {node: '>=16 || 14 >=14.17'}
-    dependencies:
-      lru-cache: 9.1.2
-      minipass: 6.0.2
-    dev: true
-
   /path-to-regexp@0.1.7:
     resolution: {integrity: sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==}
 
@@ -15810,6 +15797,14 @@ packages:
       glob: 9.3.5
     dev: true
 
+  /rimraf@5.0.1:
+    resolution: {integrity: sha512-OfFZdwtd3lZ+XZzYP/6gTACubwFcHdLRqS9UX3UwpU2dnGQYkPFISRwvM3w9IiB2w7bW5qGo/uAwE4SmXXSKvg==}
+    engines: {node: '>=14'}
+    hasBin: true
+    dependencies:
+      glob: 10.3.1
+    dev: true
+
   /ripemd160@2.0.2:
     resolution: {integrity: sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==}
     dependencies: