Merge branch 'develop' into dependabot/go_modules/github.com/libp2p/go-libp2p-0.27.8

.gitmodules

@@ -10,9 +10,6 @@
 [submodule "packages/contracts-bedrock/lib/clones-with-immutable-args"]
 	path = packages/contracts-bedrock/lib/clones-with-immutable-args
 	url = https://github.com/Saw-mon-and-Natalie/clones-with-immutable-args
-[submodule "packages/contracts-bedrock/lib/ds-test"]
-	path = packages/contracts-bedrock/lib/ds-test
-	url = https://github.com/dapphub/ds-test
 [submodule "packages/contracts-bedrock/lib/forge-std"]
 	path = packages/contracts-bedrock/lib/forge-std
 	url = https://github.com/foundry-rs/forge-std

.pnpmfile.cjs

+// This function does not modify the lockfile. It asserts that packages do not use SSH
+// when specifying git repository
+function afterAllResolved(lockfile, context) {
+  const pkgs = lockfile['packages'];
+  for (const [pkg, entry] of Object.entries(pkgs)) {
+    const repo = entry.resolution['repo'];
+    if (repo !== undefined) {
+      if (repo.startsWith('git@github.com')) {
+        throw new Error(`Invalid git ssh specification found for package ${pkg}. Ensure sure that the dependencies do not reference SSH-based git repos before running installing them`);
+      }
+    }
+  }
+  return lockfile
+}
+
+module.exports = {
+  hooks: {
+    afterAllResolved
+  }
+}

bedrock-devnet/devnet/__init__.py

@@ -9,7 +9,7 @@ import datetime
 import time
 import shutil
 import http.client
-import multiprocessing
+from multiprocessing import Process, Queue
 
 import devnet.log_setup
 
@@ -25,6 +25,26 @@ class Bunch:
     def __init__(self, **kwds):
         self.__dict__.update(kwds)
 
+class ChildProcess:
+    def __init__(self, func, *args):
+        self.errq = Queue()
+        self.process = Process(target=self._func, args=(func, args))
+
+    def _func(self, func, args):
+        try:
+            func(*args)
+        except Exception as e:
+            self.errq.put(str(e))
+
+    def start(self):
+        self.process.start()
+
+    def join(self):
+        self.process.join()
+
+    def get_error(self):
+        return self.errq.get() if not self.errq.empty() else None
+
 
 def main():
     args = parser.parse_args()
@@ -103,9 +123,12 @@ def devnet_l1_genesis(paths):
         '--verbosity', '4', '--gcmode', 'archive', '--dev.gaslimit', '30000000'
     ])
 
-    forge = multiprocessing.Process(target=deploy_contracts, args=(paths,))
+    forge = ChildProcess(deploy_contracts, paths)
     forge.start()
     forge.join()
+    err = forge.get_error()
+    if err:
+        raise Exception(f"Exception occurred in child process: {err}")
 
     res = debug_dumpBlock('127.0.0.1:8545')
     response = json.loads(res)

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

op-bindings/bindings/l1blocknumber.go

@@ -31,7 +31,7 @@ var (
 // L1BlockNumberMetaData contains all meta data concerning the L1BlockNumber contract.
 var L1BlockNumberMetaData = &bind.MetaData{
 	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"inputs\":[],\"name\":\"getL1BlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]",
-	Bin: "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",
+	Bin: "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",
 }
 
 // L1BlockNumberABI is the input ABI used to generate the binding from.

op-challenger/fault/agent.go

@@ -134,23 +134,19 @@ func (a *Agent) step(ctx context.Context, claim types.Claim, game types.Game) er
 		return nil
 	}
 
-	oracleData, err := a.solver.GetOracleData(ctx, claim)
-	if err != nil {
-		a.log.Debug("Failed to get oracle data", "err", err)
-		return nil
-	}
-
-	a.log.Info("Updating oracle data", "oracleKey", oracleData.OracleKey, "oracleData", oracleData.OracleData)
-	if err := a.updater.UpdateOracle(ctx, oracleData); err != nil {
-		return fmt.Errorf("failed to load oracle data: %w", err)
-	}
-
 	a.log.Info("Attempting step", "claim_depth", claim.Depth(), "maxDepth", a.maxDepth)
 	step, err := a.solver.AttemptStep(ctx, claim, agreeWithClaimLevel)
 	if err != nil {
 		return fmt.Errorf("attempt step: %w", err)
 	}
 
+	if step.OracleData != nil {
+		a.log.Info("Updating oracle data", "oracleKey", step.OracleData.OracleKey, "oracleData", step.OracleData.OracleData)
+		if err := a.updater.UpdateOracle(ctx, step.OracleData); err != nil {
+			return fmt.Errorf("failed to load oracle data: %w", err)
+		}
+	}
+
 	a.log.Info("Performing step", "is_attack", step.IsAttack,
 		"depth", step.LeafClaim.Depth(), "index_at_depth", step.LeafClaim.IndexAtDepth(), "value", step.LeafClaim.Value)
 	callData := types.StepCallData{

op-challenger/fault/alphabet/provider.go

@@ -30,27 +30,31 @@ func NewTraceProvider(state string, depth uint64) *AlphabetTraceProvider {
 	}
 }
 
-// GetOracleData should not return any preimage oracle data for the alphabet provider.
-func (p *AlphabetTraceProvider) GetOracleData(ctx context.Context, i uint64) (*types.PreimageOracleData, error) {
-	return &types.PreimageOracleData{}, nil
-}
-
-// GetPreimage returns the preimage for the given hash.
-func (ap *AlphabetTraceProvider) GetPreimage(ctx context.Context, i uint64) ([]byte, []byte, error) {
+func (ap *AlphabetTraceProvider) GetStepData(ctx context.Context, i uint64) ([]byte, []byte, *types.PreimageOracleData, error) {
+	if i == 0 {
+		prestate, err := ap.AbsolutePreState(ctx)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		return prestate, []byte{}, nil, nil
+	}
+	// We want the pre-state which is the value prior to the one requested
+	i--
 	// The index cannot be larger than the maximum index as computed by the depth.
 	if i >= ap.maxLen {
-		return nil, nil, ErrIndexTooLarge
+		return nil, nil, nil, ErrIndexTooLarge
 	}
 	// We extend the deepest hash to the maximum depth if the trace is not expansive.
 	if i >= uint64(len(ap.state)) {
-		return ap.GetPreimage(ctx, uint64(len(ap.state))-1)
+		return ap.GetStepData(ctx, uint64(len(ap.state)))
 	}
-	return BuildAlphabetPreimage(i, ap.state[i]), []byte{}, nil
+	return BuildAlphabetPreimage(i, ap.state[i]), []byte{}, nil, nil
 }
 
 // Get returns the claim value at the given index in the trace.
 func (ap *AlphabetTraceProvider) Get(ctx context.Context, i uint64) (common.Hash, error) {
-	claimBytes, _, err := ap.GetPreimage(ctx, i)
+	// Step data returns the pre-state, so add 1 to get the state for index i
+	claimBytes, _, _, err := ap.GetStepData(ctx, i+1)
 	if err != nil {
 		return common.Hash{}, err
 	}

op-challenger/fault/alphabet/provider_test.go

@@ -58,20 +58,21 @@ func FuzzIndexToBytes(f *testing.F) {
 
 // TestGetPreimage_Succeeds tests the GetPreimage function
 // returns the correct pre-image for a index.
-func TestGetPreimage_Succeeds(t *testing.T) {
+func TestGetStepData_Succeeds(t *testing.T) {
 	ap := NewTraceProvider("abc", 2)
 	expected := BuildAlphabetPreimage(0, "a'")
-	retrieved, proof, err := ap.GetPreimage(context.Background(), uint64(0))
+	retrieved, proof, data, err := ap.GetStepData(context.Background(), uint64(1))
 	require.NoError(t, err)
 	require.Equal(t, expected, retrieved)
 	require.Empty(t, proof)
+	require.Nil(t, data)
 }
 
 // TestGetPreimage_TooLargeIndex_Fails tests the GetPreimage
 // function errors if the index is too large.
-func TestGetPreimage_TooLargeIndex_Fails(t *testing.T) {
+func TestGetStepData_TooLargeIndex_Fails(t *testing.T) {
 	ap := NewTraceProvider("abc", 2)
-	_, _, err := ap.GetPreimage(context.Background(), 4)
+	_, _, _, err := ap.GetStepData(context.Background(), 5)
 	require.ErrorIs(t, err, ErrIndexTooLarge)
 }
 

op-challenger/fault/cannon/updater.go

@@ -87,9 +87,6 @@ func NewOracleUpdaterWithOracle(
 
 // UpdateOracle updates the oracle with the given data.
 func (u *cannonUpdater) UpdateOracle(ctx context.Context, data *types.PreimageOracleData) error {
-	if len(data.OracleKey) == 0 {
-		return nil
-	}
 	if data.IsLocal {
 		return u.sendLocalOracleData(ctx, data)
 	}

op-challenger/fault/cannon/updater_test.go

@@ -89,12 +89,6 @@ func TestCannonUpdater_UpdateOracle(t *testing.T) {
 		}))
 		require.Equal(t, 1, mockTxMgr.failedSends)
 	})
-
-	t.Run("skip empty data", func(t *testing.T) {
-		updater, mockTxMgr := newTestCannonUpdater(t, true)
-		require.NoError(t, updater.UpdateOracle(context.Background(), &types.PreimageOracleData{}))
-		require.Equal(t, 0, mockTxMgr.sends)
-	})
 }
 
 // TestCannonUpdater_BuildLocalOracleData tests the [cannonUpdater]

op-challenger/fault/service.go

@@ -10,6 +10,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/alphabet"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/cannon"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
+	"github.com/ethereum-optimism/optimism/op-service/client"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr/metrics"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -38,7 +39,7 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*se
 		return nil, fmt.Errorf("failed to create the transaction manager: %w", err)
 	}
 
-	client, err := ethclient.Dial(cfg.L1EthRpc)
+	client, err := client.DialEthClientWithTimeout(client.DefaultDialTimeout, logger, cfg.L1EthRpc)
 	if err != nil {
 		return nil, fmt.Errorf("failed to dial L1: %w", err)
 	}

op-e2e/e2eutils/disputegame/honest_helper.go

+package disputegame
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
+	"github.com/stretchr/testify/require"
+)
+
+type HonestHelper struct {
+	t            *testing.T
+	require      *require.Assertions
+	game         *FaultGameHelper
+	correctTrace types.TraceProvider
+}
+
+func (h *HonestHelper) Attack(ctx context.Context, claimIdx int64) {
+	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
+	defer cancel()
+	claim := h.game.getClaim(ctx, claimIdx)
+	pos := types.NewPositionFromGIndex(claim.Position.Uint64())
+	attackPos := pos.Attack()
+	traceIdx := attackPos.TraceIndex(int(h.game.MaxDepth(ctx)))
+	h.t.Logf("Attacking at position %v using correct trace from index %v", attackPos.ToGIndex(), traceIdx)
+	value, err := h.correctTrace.Get(ctx, traceIdx)
+	h.require.NoErrorf(err, "Get correct claim at trace index %v", traceIdx)
+	h.t.Log("Performing attack")
+	h.game.Attack(ctx, claimIdx, value)
+	h.t.Log("Attack complete")
+}
+
+func (h *HonestHelper) Defend(ctx context.Context, claimIdx int64) {
+	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
+	defer cancel()
+	claim := h.game.getClaim(ctx, claimIdx)
+	pos := types.NewPositionFromGIndex(claim.Position.Uint64())
+	defendPos := pos.Defend()
+	traceIdx := defendPos.TraceIndex(int(h.game.MaxDepth(ctx)))
+	value, err := h.correctTrace.Get(ctx, traceIdx)
+	h.game.require.NoErrorf(err, "Get correct claim at trace index %v", traceIdx)
+	h.game.Defend(ctx, claimIdx, value)
+}

op-program/host/host.go

@@ -188,13 +188,13 @@ func PreimageServer(ctx context.Context, logger log.Logger, cfg *config.Config,
 
 func makePrefetcher(ctx context.Context, logger log.Logger, kv kvstore.KV, cfg *config.Config) (*prefetcher.Prefetcher, error) {
 	logger.Info("Connecting to L1 node", "l1", cfg.L1URL)
-	l1RPC, err := client.NewRPC(ctx, logger, cfg.L1URL)
+	l1RPC, err := client.NewRPC(ctx, logger, cfg.L1URL, client.WithDialBackoff(10))
 	if err != nil {
 		return nil, fmt.Errorf("failed to setup L1 RPC: %w", err)
 	}
 
 	logger.Info("Connecting to L2 node", "l2", cfg.L2URL)
-	l2RPC, err := client.NewRPC(ctx, logger, cfg.L2URL)
+	l2RPC, err := client.NewRPC(ctx, logger, cfg.L2URL, client.WithDialBackoff(10))
 	if err != nil {
 		return nil, fmt.Errorf("failed to setup L2 RPC: %w", err)
 	}

ops-bedrock/Dockerfile.l1

-FROM ethereum/client-go:v1.12.0
+FROM ethereum/client-go:v1.12.1
 
 RUN apk add --no-cache jq
 

packages/contracts-bedrock/.eslintignore

@@ -5,6 +5,5 @@ lib
 artifacts
 forge-artifacts
 cache
-typechain
 coverage*
 deployments

packages/contracts-bedrock/.npmignore

 scripts
 test
+.envrc

packages/contracts-bedrock/.prettierignore

-# Deps and test files
-lib
-
-# build output
-artifacts
-forge-artifacts
-cache
-typechain
-coverage*
-deployments
-
-# Other autogenerated files
-gasReporterOutput.json
-slither.db.json
-
-# MIPS.sol has special VM formatting, not like other contracts.
-# Prettier also fails to handle YUL functions with multiple return variables.
-contracts/cannon/MIPS.sol

packages/contracts-bedrock/.prettierrc.js

-module.exports = {
-  ...require('../../.prettierrc.js'),
-}

packages/contracts-bedrock/.solhintignore

-# Deps and test files
-node_modules
-lib
-contracts/test/*.t.sol
-contracts/vendor/*.sol
-
-# MIPS.sol has special VM formatting, not like other contracts.
-contracts/cannon/MIPS.sol

packages/contracts-bedrock/invariant-docs/SystemConfig.md

 # `SystemConfig` Invariants
 
 ## The gas limit of the `SystemConfig` contract can never be lower than the hard-coded lower bound.
-**Test:** [`SystemConfig.t.sol#L65`](../test/invariants/SystemConfig.t.sol#L65)
+**Test:** [`SystemConfig.t.sol#L62`](../test/invariants/SystemConfig.t.sol#L62)
 

packages/contracts-bedrock/scripts/DeployConfig.s.sol

@@ -106,7 +106,7 @@ contract DeployConfig is Script {
             } catch {
                 try vm.parseJsonUint(_json, "$.l1StartingBlockTag") returns (uint256 tag) {
                     return _getBlockByTag(vm.toString(tag));
-                } catch {}
+                } catch { }
             }
         }
         revert("l1StartingBlockTag must be a bytes32, string or uint256 or cannot fetch l1StartingBlockTag");

packages/contracts-bedrock/scripts/DeployL2.s.sol

@@ -39,7 +39,7 @@ contract DeployL2 is Deployer {
     }
 
     /// @notice Deploy the EAS implementation.
-    function deployEAS() broadcast() public returns (address) {
+    function deployEAS() public broadcast returns (address) {
         EAS eas = new EAS();
 
         ISchemaRegistry registry = eas.getSchemaRegistry();
@@ -55,7 +55,7 @@ contract DeployL2 is Deployer {
     }
 
     /// @notice Deploy the SchemaManager implementation.
-    function deploySchemaRegistry() broadcast() public returns (address) {
+    function deploySchemaRegistry() public broadcast returns (address) {
         SchemaRegistry registry = new SchemaRegistry();
 
         save("SchemaRegistry", address(registry));
@@ -67,4 +67,3 @@ contract DeployL2 is Deployer {
         return address(registry);
     }
 }
-

packages/contracts-bedrock/scripts/FaultDisputeGameViz.s.sol

@@ -54,13 +54,7 @@ contract FaultDisputeGameViz is Script, FaultDisputeGame_Init {
         uint256 numClaims = uint256(vm.load(address(gameProxy), bytes32(uint256(1))));
         IFaultDisputeGame.ClaimData[] memory gameData = new IFaultDisputeGame.ClaimData[](numClaims);
         for (uint256 i = 0; i < numClaims; i++) {
-            (
-                uint32 parentIndex,
-                bool countered,
-                Claim claim,
-                Position position,
-                Clock clock
-            ) = gameProxy.claimData(i);
+            (uint32 parentIndex, bool countered, Claim claim, Position position, Clock clock) = gameProxy.claimData(i);
 
             gameData[i] = IFaultDisputeGame.ClaimData({
                 parentIndex: parentIndex,

packages/contracts-bedrock/scripts/SemverLock.s.sol

@@ -31,11 +31,7 @@ contract SemverLock is Script {
             commands = new string[](3);
             commands[0] = "bash";
             commands[1] = "-c";
-            commands[2] = string.concat(
-                "echo \"",
-                _files[i],
-                "\"| sed -E \'s|src/.*/(.+)\\.sol|\\1|\'"
-            );
+            commands[2] = string.concat("echo \"", _files[i], "\"| sed -E \'s|src/.*/(.+)\\.sol|\\1|\'");
             string memory contractName = string(vm.ffi(commands));
 
             commands[0] = "bash";
@@ -44,14 +40,8 @@ contract SemverLock is Script {
             string memory artifactsDir = string(vm.ffi(commands));
 
             // Parse the artifact to get the contract's initcode hash.
-            bytes memory initCode = vm.getCode(string.concat(
-                artifactsDir,
-                "/",
-                contractName,
-                ".sol/",
-                contractName,
-                ".json"
-            ));
+            bytes memory initCode =
+                vm.getCode(string.concat(artifactsDir, "/", contractName, ".sol/", contractName, ".json"));
 
             // Serialize the source hash in JSON.
             string memory j = vm.serializeBytes32(out, _files[i], keccak256(abi.encodePacked(fileContents, initCode)));