Merge branch 'develop' into dependabot/github_actions/actions/checkout-4

.circleci/config.yml

@@ -1142,7 +1142,7 @@ workflows:
           working_directory: proxyd
       - indexer-tests
       - go-lint-test-build:
-          name: op-heartbeat tests
+          name: op-heartbeat-tests
           binary_name: op-heartbeat
           working_directory: op-heartbeat
       - semgrep-scan
@@ -1224,7 +1224,11 @@ workflows:
           target: test-external-geth
       - bedrock-go-tests:
           requires:
+            - go-mod-tidy
+            - cannon-build-test-vectors
             - cannon-go-lint-and-test
+            - check-generated-mocks-op-node
+            - check-generated-mocks-op-service
             - op-batcher-lint
             - op-bootnode-lint
             - op-bindings-lint
@@ -1238,6 +1242,7 @@ workflows:
             - op-batcher-tests
             - op-bindings-tests
             - op-chain-ops-tests
+            - op-heartbeat-tests
             - op-node-tests
             - op-proposer-tests
             - op-challenger-tests
@@ -1245,6 +1250,7 @@ workflows:
             - op-service-tests
             - op-e2e-WS-tests
             - op-e2e-HTTP-tests
+            - op-e2e-ext-geth-tests
       - docker-build:
           name: op-node-docker-build
           docker_file: op-node/Dockerfile

bedrock-devnet/devnet/__init__.py

@@ -56,8 +56,9 @@ def main():
     deployment_dir = pjoin(contracts_bedrock_dir, 'deployments', 'devnetL1')
     op_node_dir = pjoin(args.monorepo_dir, 'op-node')
     ops_bedrock_dir = pjoin(monorepo_dir, 'ops-bedrock')
-    deploy_config_dir = pjoin(contracts_bedrock_dir, 'deploy-config'),
-    devnet_config_path = pjoin(contracts_bedrock_dir, 'deploy-config', 'devnetL1.json')
+    deploy_config_dir = pjoin(contracts_bedrock_dir, 'deploy-config')
+    devnet_config_path = pjoin(deploy_config_dir, 'devnetL1.json')
+    devnet_config_template_path = pjoin(deploy_config_dir, 'devnetL1-template.json')
     ops_chain_ops = pjoin(monorepo_dir, 'op-chain-ops')
     sdk_dir = pjoin(monorepo_dir, 'packages', 'sdk')
 
@@ -69,6 +70,7 @@ def main():
       l1_deployments_path=pjoin(deployment_dir, '.deploy'),
       deploy_config_dir=deploy_config_dir,
       devnet_config_path=devnet_config_path,
+      devnet_config_template_path=devnet_config_template_path,
       op_node_dir=op_node_dir,
       ops_bedrock_dir=ops_bedrock_dir,
       ops_chain_ops=ops_chain_ops,
@@ -124,10 +126,16 @@ def deploy_contracts(paths):
         '--rpc-url', 'http://127.0.0.1:8545'
     ], env={}, cwd=paths.contracts_bedrock_dir)
 
-
+def init_devnet_l1_deploy_config(paths, update_timestamp=False):
+    deploy_config = read_json(paths.devnet_config_template_path)
+    if update_timestamp:
+        deploy_config['l1GenesisBlockTimestamp'] = '{:#x}'.format(int(time.time()))
+    write_json(paths.devnet_config_path, deploy_config)
 
 def devnet_l1_genesis(paths):
     log.info('Generating L1 genesis state')
+    init_devnet_l1_deploy_config(paths)
+
     geth = subprocess.Popen([
         'geth', '--dev', '--http', '--http.api', 'eth,debug',
         '--verbosity', '4', '--gcmode', 'archive', '--dev.gaslimit', '30000000'
@@ -157,13 +165,13 @@ def devnet_deploy(paths):
         if os.path.exists(paths.allocs_path) == False:
             devnet_l1_genesis(paths)
 
-        devnet_config_backup = pjoin(paths.devnet_dir, 'devnetL1.json.bak')
-        shutil.copy(paths.devnet_config_path, devnet_config_backup)
-        deploy_config = read_json(paths.devnet_config_path)
-        deploy_config['l1GenesisBlockTimestamp'] = '{:#x}'.format(int(time.time()))
-        write_json(paths.devnet_config_path, deploy_config)
+        # It's odd that we want to regenerate the devnetL1.json file with
+        # an updated timestamp different than the one used in the devnet_l1_genesis
+        # function.  But, without it, CI flakes on this test rather consistently.
+        # If someone reads this comment and understands why this is being done, please
+        # update this comment to explain.
+        init_devnet_l1_deploy_config(paths, update_timestamp=True)
         outfile_l1 = pjoin(paths.devnet_dir, 'genesis-l1.json')
-
         run_command([
             'go', 'run', 'cmd/main.go', 'genesis', 'l1',
             '--deploy-config', paths.devnet_config_path,

cannon/cmd/run.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 
@@ -331,12 +330,18 @@ func Run(ctx *cli.Context) error {
 		}
 
 		if proofAt(state) {
-			preStateHash := crypto.Keccak256Hash(state.EncodeWitness())
+			preStateHash, err := state.EncodeWitness().StateHash()
+			if err != nil {
+				return fmt.Errorf("failed to hash prestate witness: %w", err)
+			}
 			witness, err := stepFn(true)
 			if err != nil {
 				return fmt.Errorf("failed at proof-gen step %d (PC: %08x): %w", step, state.PC, err)
 			}
-			postStateHash := crypto.Keccak256Hash(state.EncodeWitness())
+			postStateHash, err := state.EncodeWitness().StateHash()
+			if err != nil {
+				return fmt.Errorf("failed to hash poststate witness: %w", err)
+			}
 			proof := &Proof{
 				Step:      step,
 				Pre:       preStateHash,

cannon/cmd/witness.go

@@ -5,7 +5,6 @@ import (
 	"os"
 
 	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/urfave/cli/v2"
 )
 
@@ -31,7 +30,10 @@ func Witness(ctx *cli.Context) error {
 		return fmt.Errorf("invalid input state (%v): %w", input, err)
 	}
 	witness := state.EncodeWitness()
-	h := crypto.Keccak256Hash(witness)
+	h, err := witness.StateHash()
+	if err != nil {
+		return fmt.Errorf("failed to compute witness hash: %w", err)
+	}
 	if output != "" {
 		if err := os.WriteFile(output, witness, 0755); err != nil {
 			return fmt.Errorf("writing output to %v: %w", output, err)

cannon/example/claim/go.mod

@@ -5,8 +5,8 @@ go 1.20
 require github.com/ethereum-optimism/optimism v0.0.0
 
 require (
-	golang.org/x/crypto v0.12.0 // indirect
-	golang.org/x/sys v0.11.0 // indirect
+	golang.org/x/crypto v0.13.0 // indirect
+	golang.org/x/sys v0.12.0 // indirect
 )
 
 replace github.com/ethereum-optimism/optimism v0.0.0 => ../../..

cannon/example/claim/go.sum

 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
-golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
-golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
-golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck=
+golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
+golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

cannon/mipsevm/evm_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/eth/tracers/logger"
 	"github.com/stretchr/testify/require"
 
@@ -92,7 +91,10 @@ func (m *MIPSEVM) Step(t *testing.T, stepWitness *StepWitness) []byte {
 	logs := m.evmState.Logs()
 	require.Equal(t, 1, len(logs), "expecting a log with post-state")
 	evmPost := logs[0].Data
-	require.Equal(t, crypto.Keccak256Hash(evmPost), postHash, "logged state must be accurate")
+
+	stateHash, err := StateWitness(evmPost).StateHash()
+	require.NoError(t, err, "state hash could not be computed")
+	require.Equal(t, stateHash, postHash, "logged state must be accurate")
 
 	m.env.StateDB.RevertToSnapshot(snap)
 	t.Logf("EVM step took %d gas, and returned stateHash %s", startingGas-leftOverGas, postHash)

cannon/mipsevm/state.go

@@ -2,11 +2,16 @@ package mipsevm
 
 import (
 	"encoding/binary"
+	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
+// StateWitnessSize is the size of the state witness encoding in bytes.
+var StateWitnessSize = 226
+
 type State struct {
 	Memory *Memory `json:"memory"`
 
@@ -37,7 +42,11 @@ type State struct {
 	LastHint hexutil.Bytes `json:"lastHint,omitempty"`
 }
 
-func (s *State) EncodeWitness() []byte {
+func (s *State) VMStatus() uint8 {
+	return vmStatus(s.Exited, s.ExitCode)
+}
+
+func (s *State) EncodeWitness() StateWitness {
 	out := make([]byte, 0)
 	memRoot := s.Memory.MerkleRoot()
 	out = append(out, memRoot[:]...)
@@ -60,3 +69,41 @@ func (s *State) EncodeWitness() []byte {
 	}
 	return out
 }
+
+type StateWitness []byte
+
+const (
+	VMStatusValid      = 0
+	VMStatusInvalid    = 1
+	VMStatusPanic      = 2
+	VMStatusUnfinished = 3
+)
+
+func (sw StateWitness) StateHash() (common.Hash, error) {
+	if len(sw) != 226 {
+		return common.Hash{}, fmt.Errorf("Invalid witness length. Got %d, expected at least 88", len(sw))
+	}
+
+	hash := crypto.Keccak256Hash(sw)
+	offset := 32*2 + 4*6
+	exitCode := sw[offset]
+	exited := sw[offset+1]
+	status := vmStatus(exited == 1, exitCode)
+	hash[0] = status
+	return hash, nil
+}
+
+func vmStatus(exited bool, exitCode uint8) uint8 {
+	if !exited {
+		return VMStatusUnfinished
+	}
+
+	switch exitCode {
+	case 0:
+		return VMStatusValid
+	case 1:
+		return VMStatusInvalid
+	default:
+		return VMStatusPanic
+	}
+}

cannon/mipsevm/state_test.go

@@ -82,6 +82,53 @@ func TestState(t *testing.T) {
 	}
 }
 
+// Run through all permutations of `exited` / `exitCode` and ensure that the
+// correct witness, state hash, and VM Status is produced.
+func TestStateHash(t *testing.T) {
+	cases := []struct {
+		exited   bool
+		exitCode uint8
+	}{
+		{exited: false, exitCode: 0},
+		{exited: false, exitCode: 1},
+		{exited: false, exitCode: 2},
+		{exited: false, exitCode: 3},
+		{exited: true, exitCode: 0},
+		{exited: true, exitCode: 1},
+		{exited: true, exitCode: 2},
+		{exited: true, exitCode: 3},
+	}
+
+	exitedOffset := 32*2 + 4*6
+	for _, c := range cases {
+		state := &State{
+			Memory:   NewMemory(),
+			Exited:   c.exited,
+			ExitCode: c.exitCode,
+		}
+
+		actualWitness := state.EncodeWitness()
+		actualStateHash, err := StateWitness(actualWitness).StateHash()
+		require.NoError(t, err, "Error hashing witness")
+		require.Equal(t, len(actualWitness), StateWitnessSize, "Incorrect witness size")
+
+		expectedWitness := make(StateWitness, 226)
+		memRoot := state.Memory.MerkleRoot()
+		copy(expectedWitness[:32], memRoot[:])
+		expectedWitness[exitedOffset] = c.exitCode
+		var exited uint8
+		if c.exited {
+			exited = 1
+		}
+		expectedWitness[exitedOffset+1] = uint8(exited)
+		require.Equal(t, expectedWitness[:], actualWitness[:], "Incorrect witness")
+
+		expectedStateHash := crypto.Keccak256Hash(actualWitness)
+		expectedStateHash[0] = vmStatus(c.exited, c.exitCode)
+		require.Equal(t, expectedStateHash, actualStateHash, "Incorrect state hash")
+	}
+}
+
 func TestHello(t *testing.T) {
 	elfProgram, err := elf.Open("../example/bin/hello.elf")
 	require.NoError(t, err, "open ELF file")

docs/README.md

@@ -6,3 +6,4 @@ The directory layout is divided into the following sub-directories.
 
 - [`postmortems/`](./postmortems/): Timestamped post-mortem documents.
 - [`security-reviews`](./security-reviews/): Audit summaries and other security review documents.
+- [`fault-proof-alpha`](./fault-proof-alpha): Information on the alpha version of the fault proof system.

docs/fault-proof-alpha/README.md

+## Fault Proofs Alpha
+
+The fault proof alpha is a pre-release version of the OP Stack fault proof system.
+This documentation provides an overview of the system and instructions on how to help
+test the fault proof system.
+
+The overall design of this system along with the APIs and interfaces it exposes are not
+finalized and may change without notice.
+
+### Contents
+
+ * Overview
+ * [Deployment Details](./deployments.md)
+ * [Manual Usage](./manual.md)
+   * [Creating Traces with Cannon](./cannon.md)
+ * [Automation with `op-challenger`](./run-challenger.md)
+ * [Challenging Invalid Output Proposals](./invalid-proposals.md)

docs/fault-proof-alpha/cannon.md

+## Generate Traces with `cannon` and `op-program`
+
+Normally, `op-challenger` handles creating the required traces as part of responding to games. However, for manual
+testing it may be useful to manually generate the trace. This can be done by running `cannon` directly.
+
+### Prerequisites
+
+- The cannon pre-state downloaded from [Goerli deployment](./deployments.md#goerli).
+- A Goerli L1 node.
+    - An archive node is not required.
+    - Public RPC providers can be used, however a significant number of requests will need to be made which may exceed
+      rate limits for free plans.
+- An OP-Goerli L2 archive node with `debug` APIs enabled.
+    - An archive node is required to ensure world-state pre-images remain available.
+    - Public RPC providers are generally not usable as they don’t support the `debug_dbGet` RPC method.
+
+### Compilation
+
+To compile the required programs, in the top level of the monorepo run:
+
+```bash
+make cannon-prestate
+```
+
+This will compile the `cannon` executable to `cannon/bin/cannon` as well as the `op-program` executable used to fetch
+pre-image data to `op-program/bin/op-program`.
+
+### Run Cannon
+
+To run cannon to generate a proof use:
+
+```bash
+mkdir -p temp/cannon/proofs temp/cannon/snapshots temp/cannon/preimages
+
+./cannon/bin/cannon run \
+    --pprof.cpu \
+    --info-at '%10000000' \
+    --proof-at '=<TRACE_INDEX>' \
+    --stop-at '=<STOP_INDEX>' \
+    --proof-fmt 'temp/cannon/proofs/%d.json' \
+    --snapshot-at '%1000000000' \
+    --snapshot-fmt 'temp/cannon/snapshots/%d.json.gz' \
+    --input <PRESTATE> \
+    --output temp/cannon/stop-state.json \
+    -- \
+    ./op-program/bin/op-program \
+    --network goerli \
+    --l1 <L1_URL> \
+    --l2 <L2_URL> \
+    --l1.head <L1_HEAD> \
+    --l2.claim <L2_CLAIM> \
+    --l2.head <L2_HEAD> \
+    --l2.blocknumber <L2_BLOCK_NUMBER> \
+    --datadir temp/cannon/preimages \
+    --log.format terminal \
+    --server
+```
+
+The placeholders are:
+
+- `<TRACE_INDEX>` the index in the trace to generate a proof for
+- `<STOP_INDEX>` the index to stop execution at. Typically this is one instruction after `<TRACE_INDEX>` to stop as soon
+  as the required proof has been generated.
+- `<PRESTATE>` the prestate.json downloaded above. Note that this needs to precisely match the prestate used on-chain so
+  must be the downloaded version and not a version built locally.
+- `<L1_URL>` the Goerli L1 JSON RPC endpoint
+- `<L2_URL>` the OP-Goerli L2 archive node JSON RPC endpoint
+- `<L1_HEAD>` the hash of the L1 head block used for the dispute game
+- `<L2_CLAIM>` the output root immediately prior to the disputed root in the L2 output oracle
+- `<L2_HEAD>` the hash of the L2 block that `<L2_CLAIM>`is from
+- `<L2_BLOCK_NUMBER>` the block number that `<L2_CLAIM>` is from
+
+The generated proof will be stored in the `temp/cannon/proofs/` directory. The hash to use as the claim value is
+the `post` field of the generated proof which provides the hash of the cannon state witness after execution of the step.
+
+Since cannon can be very slow to execute, the above command uses the `--snapshot-at` option to generate a snapshot of
+the cannon state every 1000000000 instructions. Once generated, these snapshots can be used as the `--input` to begin
+execution at that step rather than from the very beginning. Generated snapshots are stored in
+the `temp/cannon/snapshots` directory.
+
+See `./cannon/bin/cannon --help` for further information on the options available.
+
+### Trace Extension
+
+Fault dispute games always use a trace with a fixed length of `2 ^ MAX_GAME_DEPTH`. The trace generated by `cannon`
+stops when the client program exits, so this trace must be extended by repeating the hash of the final state in the
+actual trace for all remaining steps. Cannon does not perform this trace extension automatically.
+
+If cannon stops execution before the trace index you requested a proof at, it simply will not generate a proof. When it
+stops executing, it will write its final state to `temp/cannon/stop-state.json` (controlled by the `--output` option).
+The `step` field of this state contains the last step cannon executed. Once the final step is known, rerun cannon to
+generate the proof at that final step and use the `post` hash as the claim value for all later trace indices.

docs/fault-proof-alpha/deployments.md

+## Fault Proof Alpha Deployment Information
+
+### Goerli
+
+Information on the fault proofs alpha deployment to Goerli is not yet available.
+
+### Local Devnet
+
+The local devnet includes a deployment of the fault proof alpha. To start the devnet, in the top level of this repo,
+run:
+
+```bash
+make devnet-up
+```
+
+| Input                | Value                                                       |
+|----------------------|-------------------------------------------------------------|
+| Dispute Game Factory | Run `jq -r .DisputeGameFactoryProxy .devnet/addresses.json` |
+| Absolute Prestate    | `op-program/bin/prestate.json`                              |
+| Max Depth            | 30                                                          |
+| Max Game Duration    | 1200 (20 minutes)                                           |
+
+See the [op-challenger README](../../op-challenger#running-with-cannon-on-local-devnet) for information on
+running `op-challenger` against the local devnet.

docs/fault-proof-alpha/invalid-proposals.md

+## Challenging Invalid Output Proposals
+
+The dispute game factory deployed to Goerli reads from the permissioned L2 Output Oracle contract. This restricts games
+to challenging valid output proposals and an honest challenger should win every game. To test creating games that
+challenge an invalid output proposal, a custom chain is required. The simplest way to do this is using the end-to-end
+test utilities in [`op-e2e`](https://github.com/ethereum-optimism/optimism/tree/develop/op-e2e).
+
+A simple starting point has been provided in the `TestCannonProposedOutputRootInvalid` test case
+in [`faultproof_test.go`](https://github.com/ethereum-optimism/optimism/blob/6e174ae2b2587d9ac5e2930d7574f85d254ca8b4/op-e2e/faultproof_test.go#L334).
+This is a table test that takes the output root to propose, plus functions for move and step to counter the honest
+claims. The test asserts that the defender always wins and thus the output root is found to be invalid.

docs/fault-proof-alpha/manual.md

+## Manual Fault Proof Interactions
+
+### Creating a Game
+
+The process of disputing an output root starts by creating a new dispute game. There are conceptually three key inputs
+required for a dispute game:
+
+- The output root being disputed
+- The agreed output root the derivation process will start from
+- The L1 head block that defines the canonical L1 chain containing all required batch data to perform the derivation
+
+The creator of the game selects the output root to dispute. It is identified by its L2 block number which can be used to
+look up the full details in the L2 output oracle.
+
+The agreed output root is defined as the output root immediately prior to the disputed output root in the L2 output
+oracle. Therefore, a dispute game should only be created for the first invalid output root. If it is successfully
+disputed, all output roots after it are considered invalid by inference.
+
+The L1 head block can be any L1 block where the disputed output root is present in the L2 output oracle. Proposers
+should therefore ensure that all batch data has been submitted to L1 before submitting a proposal. The L1 head block is
+recorded in the `BlockOracle` and then referenced by its block number.
+
+Creating a game requires two separate transactions. First the L1 head block is recorded in the `BlockOracle` by calling
+its `checkpoint` function. This records the parent of the block the transaction is included in. The `BlockOracle` emits
+a log `Checkpoint(blockNumber, blockHash, childTimestamp)`.
+
+Now, using the L1 head along with output root info available in the L2 output oracle, cannon can be executed to
+determine the root claim to use when creating the game. In simple cases, where the claim is expected to be incorrect, an
+arbitrary hash can be used for claim values. For more advanced cases [cannon can be used](./cannon.md) to generate a
+trace, including the claim values to use at specific steps. Note that it is not valid to create a game that disputes an
+output root, using the final hash from a trace that confirms the output root is valid. To dispute an output root
+successfully, the trace must resolve that the disputed output root is invalid.
+
+The game can then be created by calling the `create` method on the `DisputeGameFactory` contract. This requires three
+parameters:
+
+- `gameType` - a `uint8` representing the type of game to create. For fault dispute games using cannon and op-program
+  traces, the game type is 0.
+- `rootClaim` - a `bytes32` hash of the final state from the trace.
+- `extraData` - arbitrary bytes which are used as the initial inputs for the game. For fault dispute games using cannon
+  and op-program traces, this is the abi encoding of `(uint256(l2_block_number), uint256(l1_checkpoint))`.
+    - `l2_block_number` is the L2 block number from the output root being disputed
+    - `l1_checkpoint` is the L1 block number recorded by the `BlockOracle` checkpoint
+
+This emits a log event `DisputeGameCreated(gameAddress, gameType, rootClaim)` where `gameAddress` is the address of the
+newly created dispute game.
+
+The helper script, [create_game.sh](../../op-challenger#create_gamesh) can be used to easily create a new dispute
+game and also acts as an example of using `cast` to manually create a game.
+
+### Performing Moves
+
+The dispute game progresses by actors countering existing claims via either the `attack` or `defend` methods in
+the `FaultDisputeGame` contract. Note that only `attack` can be used to counter the root claim. In both cases, there are
+two inputs required:
+
+- `parentIndex` - the index in the claims array of the parent claim that is being countered.
+- `claim` - a `bytes32` hash of the state at the trace index corresponding to the new claim’s position.
+
+The helper script, [move.sh](../../op-challenger#movesh), can be used to easily perform moves and also
+acts as an example of using `cast` to manually call `attack` and `defend`.
+
+### Performing Steps
+
+Attacking or defending are teh only available actions before the maximum depth of the game is reached. To counter claims
+at the maximum depth, a step must be performed instead. Calling the `step` method in the `FaultDisputeGame` contract
+counters a claim at the maximum depth by running a single step of the cannon VM on chain. The `step` method will revert
+unless the cannon execution confirms the claim being countered is invalid. Note, if an actor's clock runs out at any
+point, the game can be [resolved](#resolving-a-game).
+
+The inputs for step are:
+
+- `claimIndex` - the index in the claims array of the claim that is being countered
+- `isAttack` - Similar to regular moves, steps can either be attacking or defending
+- `stateData` - the full cannon state witness to use as the starting state for execution
+- `proof` - the additional proof data for the state witness required by cannon to perform the step
+
+When a step is attacking, the caller is asserting that the claim at `claimIndex` is incorrect, and the claim for
+the previous trace index (made at a previous level in the game) was correct. The `stateData` must be the pre-image for
+the agreed correct hash at the previous trace index. The call to `step` will revert if the post-state from cannon
+matches the claim at `claimIndex` since the on-chain execution has proven the claim correct and it should not be
+countered.
+
+When a step is defending, the caller is asserting that the claim at `claimIndex` is correct, and the claim for
+the next trace index (made at a previous level in the game) is incorrect. The `stateData` must be the pre-image for the
+hash in the claim at `claimIndex`.
+
+The `step` function will revert with `ValidStep()` if the cannon execution proves that the claim attempting to be
+countered is correct. As a result, claims at the maximum game depth can only be countered by a valid execution of the
+single instruction in cannon running on-chain.
+
+#### Populating the Pre-image Oracle
+
+When the instruction to be executed as part of a `step` call reads from some pre-image data, that data must be loaded
+into the pre-image oracle prior to calling `step`.
+For [local pre-image keys](../../specs/fault-proof.md#type-1-local-key), the pre-image must be populated via
+the `FaultDisputeGame` contract by calling the `addLocalData` function.
+For [global keccak256 keys](../../specs/fault-proof.md#type-2-global-keccak256-key), the data should be added directly
+to the pre-image oracle contract.
+
+### Resolving a Game
+
+The final action required for a game is to resolve it by calling the `resolve` method in the `FaultDisputeGame`
+contract. This can only be done once the clock of the left-most uncontested claim’s parent has expired. A game can only
+be resolved once.
+
+There are no inputs required for the `resolve` method. When successful, a log event is emitted with the game’s final
+status.
+
+The helper script, [resolve.sh](../../op-challenger#resolvesh), can be used to easily resolve a game and also acts as an
+example of using `cast` to manually call `resolve` and understand the result.

docs/fault-proof-alpha/run-challenger.md

+## Running op-challenger
+
+`op-challenger` is a program that implements the honest actor algorithm to automatically “play” the dispute games.
+
+### Prerequisites
+
+- The cannon pre-state downloaded from [Goerli deployment](./deployments.md#goerli).
+- An account on the Goerli testnet with funds available. The amount of GöETH required depends on the number of claims
+  the challenger needs to post, but 0.01 ETH should be plenty to start.
+- A Goerli L1 node.
+    - An archive node is not required.
+    - Public RPC providers can be used, however a significant number of requests will need to be made which may exceed
+      rate limits for free plans.
+- An OP-Goerli L2 archive node with `debug` APIs enabled.
+    - An archive node is required to ensure world-state pre-images remain available.
+    - Public RPC providers are generally not usable as they don’t support the `debug_dbGet` RPC method.
+- Approximately 3.5Gb of disk space for each game being played.
+
+### Starting op-challenger
+
+When executing `op-challenger`, there are a few placeholders that need to be set to concreate values:
+
+- `<L1_URL>` the Goerli L1 JSON RPC endpoint
+- `<DISPUTE_GAME_FACTORY_ADDRESS>` the address of the dispute game factory contract (see
+  the [Goerli deployment details](./deployments.md#goerli))
+- `<PRESTATE>` the prestate.json downloaded above. Note that this needs to precisely match the prestate used on-chain so
+  must be the downloaded version and not a version built locally (see the [Goerli deployment details](./deployments.md#goerli))
+- `<L2_URL>` the OP-Goerli L2 archive node JSON RPC endpoint
+- `<PRIVATE_KEY>` the private key for a funded Goerli account. For other ways to specify the account to use
+  see `./op-challenger/bin/op-challenger --help`
+
+From inside the monorepo directory, run the challenger with these placeholders set.
+
+```bash
+# Build the required components
+make op-challenger op-program cannon
+
+# Run op-challenger
+./op-challenger/bin/op-challenger \
+  --trace-type cannon \
+  --l1-eth-rpc <L1_URL> \
+  --game-factory-address <DISPUTE_GAME_FACTORY_ADDRESS> \
+  --agree-with-proposed-output=true \
+  --datadir temp/challenger-goerli \
+  --cannon-network goerli \
+  --cannon-bin ./cannon/bin/cannon \
+  --cannon-server ./op-program/bin/op-program \
+  --cannon-prestate <PRESTATE> \
+  --cannon-l2 <L2_URL> \
+  --private-key <PRIVATE_KEY>
+```
+
+
+### Restricting Games to Play
+
+By default `op-challenger` will generate traces and respond to any game created by the dispute game factory contract. On
+a public testnet like Goerli, that could be a large number of games, requiring significant CPU and disk resources. To
+avoid this, `op-challenger` supports specifying an allowlist of games for it to respond to with the `--game-allowlist`
+option.
+
+```bash
+./op-challenger/bin/op-challenger \
+  ... \
+  --game-allowlist <GAME_ADDR> <GAME_ADDR> <GAME_ADDR>...
+```

endpoint-monitor/Dockerfile

@@ -2,18 +2,21 @@ FROM golang:1.20.7-alpine3.18 as builder
 
 RUN apk --no-cache add make jq bash git alpine-sdk
 
+COPY ./go.mod /app/go.mod
+COPY ./go.sum /app/go.sum
+
+WORKDIR /app
+
+RUN go mod download
+
 COPY ./endpoint-monitor /app/endpoint-monitor
 COPY ./op-service /app/op-service
 COPY ./op-node /app/op-node
-COPY ./go.mod /app/go.mod
-COPY ./go.sum /app/go.sum
 
 COPY ./.git /app/.git
 
 WORKDIR /app/endpoint-monitor
 
-RUN go mod download
-
 RUN make build
 
 FROM alpine:3.18

go.mod

@@ -38,10 +38,10 @@ require (
 	github.com/prometheus/client_golang v1.14.0
 	github.com/stretchr/testify v1.8.4
 	github.com/urfave/cli/v2 v2.25.7
-	golang.org/x/crypto v0.12.0
+	golang.org/x/crypto v0.13.0
 	golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df
 	golang.org/x/sync v0.3.0
-	golang.org/x/term v0.11.0
+	golang.org/x/term v0.12.0
 	golang.org/x/time v0.3.0
 	gorm.io/driver/postgres v1.5.2
 	gorm.io/gorm v1.25.4
@@ -195,8 +195,8 @@ require (
 	go.uber.org/zap v1.24.0 // indirect
 	golang.org/x/mod v0.11.0 // indirect
 	golang.org/x/net v0.12.0 // indirect
-	golang.org/x/sys v0.11.0 // indirect
-	golang.org/x/text v0.12.0 // indirect
+	golang.org/x/sys v0.12.0 // indirect
+	golang.org/x/text v0.13.0 // indirect
 	golang.org/x/tools v0.9.3 // indirect
 	google.golang.org/protobuf v1.30.0 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect

go.sum

@@ -886,8 +886,8 @@ golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm
 golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
-golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
+golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck=
+golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df h1:UA2aFVmmsIlefxMk29Dp2juaUSth8Pyn3Tq5Y5mJGME=
 golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
@@ -1008,13 +1008,13 @@ golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
-golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.11.0 h1:F9tnn/DA/Im8nCwm+fX+1/eBwi4qFjRT++MhtVC4ZX0=
-golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
+golang.org/x/term v0.12.0 h1:/ZfYdc3zq+q02Rv9vGqTeSItdzZTSNDmfTi0mBAuidU=
+golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -1023,8 +1023,8 @@ golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
-golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=

indexer/Dockerfile

@@ -2,18 +2,21 @@ FROM --platform=$BUILDPLATFORM golang:1.20.7-alpine3.18 as builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers git jq bash
 
+COPY ./go.mod /app/go.mod
+COPY ./go.sum /app/go.sum
+
+WORKDIR /app
+
+RUN go mod download
+
 # build indexer with the shared go.mod & go.sum files
 COPY ./indexer /app/indexer
 COPY ./op-bindings /app/op-bindings
 COPY ./op-service /app/op-service
 COPY ./op-node /app/op-node
-COPY ./go.mod /app/go.mod
-COPY ./go.sum /app/go.sum
 
 WORKDIR /app/indexer
 
-RUN go mod download
-
 RUN make indexer
 
 FROM alpine:3.18

indexer/api/api.go

@@ -4,42 +4,114 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"runtime/debug"
+	"sync"
 
 	"github.com/ethereum-optimism/optimism/indexer/api/routes"
+	"github.com/ethereum-optimism/optimism/indexer/config"
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/op-service/httputil"
+	"github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
+	"github.com/prometheus/client_golang/prometheus"
 )
 
 const ethereumAddressRegex = `^0x[a-fA-F0-9]{40}$`
 
 type Api struct {
-	log    log.Logger
-	Router *chi.Mux
+	log             log.Logger
+	Router          *chi.Mux
+	serverConfig    config.ServerConfig
+	metricsConfig   config.ServerConfig
+	metricsRegistry *prometheus.Registry
 }
 
-func NewApi(logger log.Logger, bv database.BridgeTransfersView) *Api {
-	r := chi.NewRouter()
-	h := routes.NewRoutes(logger, bv, r)
+const (
+	MetricsNamespace = "op_indexer"
+)
+
+func chiMetricsMiddleware(rec metrics.HTTPRecorder) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return metrics.NewHTTPRecordingMiddleware(rec, next)
+	}
+}
+
+func NewApi(logger log.Logger, bv database.BridgeTransfersView, serverConfig config.ServerConfig, metricsConfig config.ServerConfig) *Api {
+	apiRouter := chi.NewRouter()
+	h := routes.NewRoutes(logger, bv, apiRouter)
+
+	mr := metrics.NewRegistry()
+	promRecorder := metrics.NewPromHTTPRecorder(mr, MetricsNamespace)
+
+	apiRouter.Use(chiMetricsMiddleware(promRecorder))
+	apiRouter.Use(middleware.Recoverer)
+	apiRouter.Use(middleware.Heartbeat("/healthz"))
+
+	apiRouter.Get(fmt.Sprintf("/api/v0/deposits/{address:%s}", ethereumAddressRegex), h.L1DepositsHandler)
+	apiRouter.Get(fmt.Sprintf("/api/v0/withdrawals/{address:%s}", ethereumAddressRegex), h.L2WithdrawalsHandler)
+
+	return &Api{log: logger, Router: apiRouter, metricsRegistry: mr, serverConfig: serverConfig, metricsConfig: metricsConfig}
+}
+
+func (a *Api) Start(ctx context.Context) error {
+	var wg sync.WaitGroup
+	errCh := make(chan error, 2)
+
+	processCtx, processCancel := context.WithCancel(ctx)
+	runProcess := func(start func(ctx context.Context) error) {
+		wg.Add(1)
+		go func() {
+			defer func() {
+				if err := recover(); err != nil {
+					a.log.Error("halting api on panic", "err", err)
+					debug.PrintStack()
+					errCh <- fmt.Errorf("panic: %v", err)
+				}
+
+				processCancel()
+				wg.Done()
+			}()
 
-	r.Use(middleware.Heartbeat("/healthz"))
+			errCh <- start(processCtx)
+		}()
+	}
+
+	runProcess(a.startServer)
+	runProcess(a.startMetricsServer)
+
+	wg.Wait()
+
+	err := <-errCh
+	if err != nil {
+		a.log.Error("api stopped", "err", err)
+	} else {
+		a.log.Info("api stopped")
+	}
 
-	r.Get(fmt.Sprintf("/api/v0/deposits/{address:%s}", ethereumAddressRegex), h.L1DepositsHandler)
-	r.Get(fmt.Sprintf("/api/v0/withdrawals/{address:%s}", ethereumAddressRegex), h.L2WithdrawalsHandler)
-	return &Api{log: logger, Router: r}
+	return err
 }
 
-func (a *Api) Listen(ctx context.Context, port int) error {
-	a.log.Info("api server listening...", "port", port)
-	server := http.Server{Addr: fmt.Sprintf(":%d", port), Handler: a.Router}
+func (a *Api) startServer(ctx context.Context) error {
+	a.log.Info("api server listening...", "port", a.serverConfig.Port)
+	server := http.Server{Addr: fmt.Sprintf(":%d", a.serverConfig.Port), Handler: a.Router}
 	err := httputil.ListenAndServeContext(ctx, &server)
 	if err != nil {
 		a.log.Error("api server stopped", "err", err)
 	} else {
 		a.log.Info("api server stopped")
 	}
+	return err
+}
 
+func (a *Api) startMetricsServer(ctx context.Context) error {
+	a.log.Info("starting metrics server...", "port", a.metricsConfig.Port)
+	err := metrics.ListenAndServe(ctx, a.metricsRegistry, a.metricsConfig.Host, a.metricsConfig.Port)
+	if err != nil {
+		a.log.Error("metrics server stopped", "err", err)
+	} else {
+		a.log.Info("metrics server stopped")
+	}
 	return err
 }

indexer/api/api_test.go

@@ -6,6 +6,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/indexer/config"
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
@@ -18,6 +19,15 @@ type MockBridgeTransfersView struct{}
 
 var mockAddress = "0x4204204204204204204204204204204204204204"
 
+var apiConfig = config.ServerConfig{
+	Host: "localhost",
+	Port: 8080,
+}
+var metricsConfig = config.ServerConfig{
+	Host: "localhost",
+	Port: 7300,
+}
+
 var (
 	deposit = database.L1BridgeDeposit{
 		TransactionSourceHash: common.HexToHash("abc"),
@@ -77,7 +87,7 @@ func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalsByAddress(address common.
 }
 func TestHealthz(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(logger, &MockBridgeTransfersView{})
+	api := NewApi(logger, &MockBridgeTransfersView{}, apiConfig, metricsConfig)
 	request, err := http.NewRequest("GET", "/healthz", nil)
 	assert.Nil(t, err)
 
@@ -89,7 +99,7 @@ func TestHealthz(t *testing.T) {
 
 func TestL1BridgeDepositsHandler(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(logger, &MockBridgeTransfersView{})
+	api := NewApi(logger, &MockBridgeTransfersView{}, apiConfig, metricsConfig)
 	request, err := http.NewRequest("GET", fmt.Sprintf("/api/v0/deposits/%s", mockAddress), nil)
 	assert.Nil(t, err)
 
@@ -101,7 +111,7 @@ func TestL1BridgeDepositsHandler(t *testing.T) {
 
 func TestL2BridgeWithdrawalsByAddressHandler(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(logger, &MockBridgeTransfersView{})
+	api := NewApi(logger, &MockBridgeTransfersView{}, apiConfig, metricsConfig)
 	request, err := http.NewRequest("GET", fmt.Sprintf("/api/v0/withdrawals/%s", mockAddress), nil)
 	assert.Nil(t, err)
 

indexer/bigint/bigint.go

+package bigint
+
+import "math/big"
+
+var (
+	Zero = big.NewInt(0)
+	One  = big.NewInt(1)
+)
+
+// Clamp returns a new big.Int for `end` to which `end - start` <= size.
+// @note (start, end) is an inclusive range
+func Clamp(start, end *big.Int, size uint64) *big.Int {
+	temp := new(big.Int)
+	count := temp.Sub(end, start).Uint64() + 1
+	if count <= size {
+		return end
+	}
+
+	// we re-use the allocated temp as the new end
+	temp.Add(start, big.NewInt(int64(size-1)))
+	return temp
+}
+
+// Matcher returns an inner comparison function result for a big.Int
+func Matcher(num int64) func(*big.Int) bool {
+	return func(bi *big.Int) bool { return bi.Int64() == num }
+}
+
+type Range struct {
+	Start *big.Int
+	End   *big.Int
+}
+
+// Grouped will return a slice of inclusive ranges from (start, end),
+// capped to the supplied size from `(start, end)`.
+func Grouped(start, end *big.Int, size uint64) []Range {
+	if end.Cmp(start) < 0 || size == 0 {
+		return nil
+	}
+
+	bigMaxDiff := big.NewInt(int64(size - 1))
+
+	groups := []Range{}
+	for start.Cmp(end) <= 0 {
+		diff := new(big.Int).Sub(end, start)
+		switch {
+		case diff.Uint64()+1 <= size:
+			// re-use allocated diff as the next start
+			groups = append(groups, Range{start, end})
+			start = diff.Add(end, One)
+		default:
+			// re-use allocated diff as the next start
+			end := new(big.Int).Add(start, bigMaxDiff)
+			groups = append(groups, Range{start, end})
+			start = diff.Add(end, One)
+		}
+	}
+
+	return groups
+}

indexer/bigint/bigint_test.go

+package bigint
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestClamp(t *testing.T) {
+	start := big.NewInt(1)
+	end := big.NewInt(10)
+
+	// When the (start, end) bounds are within range
+	// the same end pointer should be returned
+
+	// larger range
+	result := Clamp(start, end, 20)
+	require.True(t, end == result)
+
+	// exact range
+	result = Clamp(start, end, 10)
+	require.True(t, end == result)
+
+	// smaller range
+	result = Clamp(start, end, 5)
+	require.False(t, end == result)
+	require.Equal(t, uint64(5), result.Uint64())
+}
+
+func TestGrouped(t *testing.T) {
+	// base cases
+	require.Nil(t, Grouped(One, Zero, 1))
+	require.Nil(t, Grouped(Zero, One, 0))
+
+	// Same Start/End
+	group := Grouped(One, One, 1)
+	require.Len(t, group, 1)
+	require.Equal(t, One, group[0].Start)
+	require.Equal(t, One, group[0].End)
+
+	Three, Five := big.NewInt(3), big.NewInt(5)
+
+	// One at a time
+	group = Grouped(One, Three, 1)
+	require.Equal(t, One, group[0].End)
+	require.Equal(t, int64(1), group[0].End.Int64())
+	require.Equal(t, int64(2), group[1].Start.Int64())
+	require.Equal(t, int64(2), group[1].End.Int64())
+	require.Equal(t, int64(3), group[2].Start.Int64())
+	require.Equal(t, int64(3), group[2].End.Int64())
+
+	// Split groups
+	group = Grouped(One, Five, 3)
+	require.Len(t, group, 2)
+	require.Equal(t, One, group[0].Start)
+	require.Equal(t, int64(3), group[0].End.Int64())
+	require.Equal(t, int64(4), group[1].Start.Int64())
+	require.Equal(t, Five, group[1].End)
+
+	// Encompasses the range
+	group = Grouped(One, Five, 5)
+	require.Len(t, group, 1)
+	require.Equal(t, One, group[0].Start, Zero)
+	require.Equal(t, Five, group[0].End)
+
+	// Size larger than the entire range
+	group = Grouped(One, Five, 100)
+	require.Len(t, group, 1)
+	require.Equal(t, One, group[0].Start, Zero)
+	require.Equal(t, Five, group[0].End)
+}

indexer/cmd/indexer/cli.go

@@ -62,8 +62,8 @@ func runApi(ctx *cli.Context) error {
 	}
 	defer db.Close()
 
-	api := api.NewApi(log, db.BridgeTransfers)
-	return api.Listen(ctx.Context, cfg.HTTPServer.Port)
+	api := api.NewApi(log, db.BridgeTransfers, cfg.HTTPServer, cfg.MetricsServer)
+	return api.Start(ctx.Context)
 }
 
 func runAll(ctx *cli.Context) error {

indexer/config/config.go

@@ -120,12 +120,12 @@ func LoadConfig(logger geth_log.Logger, path string) (Config, error) {
 	}
 
 	if conf.Chain.Preset != 0 {
-		knownContracts, ok := presetL1Contracts[conf.Chain.Preset]
-		if ok {
-			conf.Chain.L1Contracts = knownContracts
-		} else {
+		knownPreset, ok := presetConfigs[conf.Chain.Preset]
+		if !ok {
 			return conf, fmt.Errorf("unknown preset: %d", conf.Chain.Preset)
 		}
+		conf.Chain.L1Contracts = knownPreset.L1Contracts
+		conf.Chain.L1StartingHeight = knownPreset.L1StartingHeight
 	}
 
 	// Set polling defaults if not set

indexer/config/config_test.go

@@ -54,10 +54,10 @@ func TestLoadConfig(t *testing.T) {
 	require.NoError(t, err)
 
 	require.Equal(t, conf.Chain.Preset, 420)
-	require.Equal(t, conf.Chain.L1Contracts.OptimismPortalProxy.String(), presetL1Contracts[420].OptimismPortalProxy.String())
-	require.Equal(t, conf.Chain.L1Contracts.L1CrossDomainMessengerProxy.String(), presetL1Contracts[420].L1CrossDomainMessengerProxy.String())
-	require.Equal(t, conf.Chain.L1Contracts.L1StandardBridgeProxy.String(), presetL1Contracts[420].L1StandardBridgeProxy.String())
-	require.Equal(t, conf.Chain.L1Contracts.L2OutputOracleProxy.String(), presetL1Contracts[420].L2OutputOracleProxy.String())
+	require.Equal(t, conf.Chain.L1Contracts.OptimismPortalProxy.String(), presetConfigs[420].L1Contracts.OptimismPortalProxy.String())
+	require.Equal(t, conf.Chain.L1Contracts.L1CrossDomainMessengerProxy.String(), presetConfigs[420].L1Contracts.L1CrossDomainMessengerProxy.String())
+	require.Equal(t, conf.Chain.L1Contracts.L1StandardBridgeProxy.String(), presetConfigs[420].L1Contracts.L1StandardBridgeProxy.String())
+	require.Equal(t, conf.Chain.L1Contracts.L2OutputOracleProxy.String(), presetConfigs[420].L1Contracts.L2OutputOracleProxy.String())
 	require.Equal(t, conf.RPCs.L1RPC, "https://l1.example.com")
 	require.Equal(t, conf.RPCs.L2RPC, "https://l2.example.com")
 	require.Equal(t, conf.DB.Host, "127.0.0.1")

indexer/config/presets.go

@@ -5,49 +5,67 @@ import (
 )
 
 // in future presets can just be onchain config and fetched on initialization
-
 // Mapping of l2 chain ids to their preset chain configurations
-var presetL1Contracts = map[int]L1Contracts{
+var presetConfigs = map[int]ChainConfig{
 	// OP Mainnet
 	10: {
-		OptimismPortalProxy:         common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
-		L2OutputOracleProxy:         common.HexToAddress("0xdfe97868233d1aa22e815a266982f2cf17685a27"),
-		L1CrossDomainMessengerProxy: common.HexToAddress("0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1"),
-		L1StandardBridgeProxy:       common.HexToAddress("0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"),
+		L1Contracts: L1Contracts{
+			OptimismPortalProxy:         common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
+			L2OutputOracleProxy:         common.HexToAddress("0xdfe97868233d1aa22e815a266982f2cf17685a27"),
+			L1CrossDomainMessengerProxy: common.HexToAddress("0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1"),
+			L1StandardBridgeProxy:       common.HexToAddress("0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"),
+			// LegacyCanonicalTransactionChain: common.HexToAddress("0x5e4e65926ba27467555eb562121fac00d24e9dd2"),
+		},
+		L1StartingHeight: 13596466,
 	},
 	// OP Goerli
 	420: {
-		OptimismPortalProxy:         common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
-		L2OutputOracleProxy:         common.HexToAddress("0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"),
-		L1CrossDomainMessengerProxy: common.HexToAddress("0x5086d1eEF304eb5284A0f6720f79403b4e9bE294"),
-		L1StandardBridgeProxy:       common.HexToAddress("0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"),
+		L1Contracts: L1Contracts{
+			OptimismPortalProxy:         common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
+			L2OutputOracleProxy:         common.HexToAddress("0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"),
+			L1CrossDomainMessengerProxy: common.HexToAddress("0x5086d1eEF304eb5284A0f6720f79403b4e9bE294"),
+			L1StandardBridgeProxy:       common.HexToAddress("0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"),
+		},
+		L1StartingHeight: 7017096,
 	},
 	// Base Mainnet
 	8453: {
-		OptimismPortalProxy:         common.HexToAddress("0x49048044D57e1C92A77f79988d21Fa8fAF74E97e"),
-		L2OutputOracleProxy:         common.HexToAddress("0x56315b90c40730925ec5485cf004d835058518A0"),
-		L1CrossDomainMessengerProxy: common.HexToAddress("0x866E82a600A1414e583f7F13623F1aC5d58b0Afa"),
-		L1StandardBridgeProxy:       common.HexToAddress("0x3154Cf16ccdb4C6d922629664174b904d80F2C35"),
+		L1Contracts: L1Contracts{
+			OptimismPortalProxy:         common.HexToAddress("0x49048044D57e1C92A77f79988d21Fa8fAF74E97e"),
+			L2OutputOracleProxy:         common.HexToAddress("0x56315b90c40730925ec5485cf004d835058518A0"),
+			L1CrossDomainMessengerProxy: common.HexToAddress("0x866E82a600A1414e583f7F13623F1aC5d58b0Afa"),
+			L1StandardBridgeProxy:       common.HexToAddress("0x3154Cf16ccdb4C6d922629664174b904d80F2C35"),
+		},
+		L1StartingHeight: 17481768,
 	},
 	// Base Goerli
 	84531: {
-		OptimismPortalProxy:         common.HexToAddress("0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"),
-		L2OutputOracleProxy:         common.HexToAddress("0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"),
-		L1CrossDomainMessengerProxy: common.HexToAddress("0x8e5693140eA606bcEB98761d9beB1BC87383706D"),
-		L1StandardBridgeProxy:       common.HexToAddress("0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"),
+		L1Contracts: L1Contracts{
+			OptimismPortalProxy:         common.HexToAddress("0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"),
+			L2OutputOracleProxy:         common.HexToAddress("0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"),
+			L1CrossDomainMessengerProxy: common.HexToAddress("0x8e5693140eA606bcEB98761d9beB1BC87383706D"),
+			L1StandardBridgeProxy:       common.HexToAddress("0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"),
+		},
+		L1StartingHeight: 8410981,
 	},
 	// Zora mainnet
 	7777777: {
-		OptimismPortalProxy:         common.HexToAddress("0x1a0ad011913A150f69f6A19DF447A0CfD9551054"),
-		L2OutputOracleProxy:         common.HexToAddress("0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"),
-		L1CrossDomainMessengerProxy: common.HexToAddress("0xdC40a14d9abd6F410226f1E6de71aE03441ca506"),
-		L1StandardBridgeProxy:       common.HexToAddress("0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"),
+		L1Contracts: L1Contracts{
+			OptimismPortalProxy:         common.HexToAddress("0x1a0ad011913A150f69f6A19DF447A0CfD9551054"),
+			L2OutputOracleProxy:         common.HexToAddress("0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"),
+			L1CrossDomainMessengerProxy: common.HexToAddress("0xdC40a14d9abd6F410226f1E6de71aE03441ca506"),
+			L1StandardBridgeProxy:       common.HexToAddress("0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"),
+		},
+		L1StartingHeight: 17473923,
 	},
 	// Zora goerli
 	999: {
-		OptimismPortalProxy:         common.HexToAddress("0xDb9F51790365e7dc196e7D072728df39Be958ACe"),
-		L2OutputOracleProxy:         common.HexToAddress("0xdD292C9eEd00f6A32Ff5245d0BCd7f2a15f24e00"),
-		L1CrossDomainMessengerProxy: common.HexToAddress("0xD87342e16352D33170557A7dA1e5fB966a60FafC"),
-		L1StandardBridgeProxy:       common.HexToAddress("0x7CC09AC2452D6555d5e0C213Ab9E2d44eFbFc956"),
+		L1Contracts: L1Contracts{
+			OptimismPortalProxy:         common.HexToAddress("0xDb9F51790365e7dc196e7D072728df39Be958ACe"),
+			L2OutputOracleProxy:         common.HexToAddress("0xdD292C9eEd00f6A32Ff5245d0BCd7f2a15f24e00"),
+			L1CrossDomainMessengerProxy: common.HexToAddress("0xD87342e16352D33170557A7dA1e5fB966a60FafC"),
+			L1StandardBridgeProxy:       common.HexToAddress("0x7CC09AC2452D6555d5e0C213Ab9E2d44eFbFc956"),
+		},
+		L1StartingHeight: 8942381,
 	},
 }

indexer/database/blocks.go

 package database
 
 import (
-	"context"
 	"errors"
 	"math/big"
 
@@ -104,17 +103,17 @@ func newBlocksDB(db *gorm.DB) BlocksDB {
 // L1
 
 func (db *blocksDB) StoreL1BlockHeaders(headers []L1BlockHeader) error {
-	result := db.gorm.Create(&headers)
+	result := db.gorm.CreateInBatches(&headers, batchInsertSize)
 	return result.Error
 }
 
 func (db *blocksDB) StoreLegacyStateBatches(stateBatches []LegacyStateBatch) error {
-	result := db.gorm.Create(stateBatches)
+	result := db.gorm.CreateInBatches(stateBatches, batchInsertSize)
 	return result.Error
 }
 
 func (db *blocksDB) StoreOutputProposals(outputs []OutputProposal) error {
-	result := db.gorm.Create(outputs)
+	result := db.gorm.CreateInBatches(outputs, batchInsertSize)
 	return result.Error
 }
 
@@ -180,7 +179,7 @@ func (db *blocksDB) OutputProposal(index *big.Int) (*OutputProposal, error) {
 // L2
 
 func (db *blocksDB) StoreL2BlockHeaders(headers []L2BlockHeader) error {
-	result := db.gorm.Create(&headers)
+	result := db.gorm.CreateInBatches(&headers, batchInsertSize)
 	return result.Error
 }
 
@@ -211,7 +210,6 @@ func (db *blocksDB) L2LatestBlockHeader() (*L2BlockHeader, error) {
 		return nil, result.Error
 	}
 
-	result.Logger.Info(context.Background(), "number ", l2Header.Number)
 	return &l2Header, nil
 }
 
@@ -229,12 +227,32 @@ type Epoch struct {
 // For more, see the protocol spec:
 //   - https://github.com/ethereum-optimism/optimism/blob/develop/specs/derivation.md
 func (db *blocksDB) LatestEpoch() (*Epoch, error) {
-	// Since L1 blocks occur less frequently than L2, we do a INNER JOIN from L1 on
-	// L2 for a faster query. Per the protocol, the L2 block that starts a new epoch
-	// will have a matching timestamp with the L1 origin.
-	query := db.gorm.Table("l1_block_headers").Order("l1_block_headers.timestamp DESC")
-	query = query.Joins("INNER JOIN l2_block_headers ON l1_block_headers.timestamp = l2_block_headers.timestamp")
-	query = query.Select("*")
+	latestL1Header, err := db.L1LatestBlockHeader()
+	if err != nil {
+		return nil, err
+	} else if latestL1Header == nil {
+		return nil, nil
+	}
+
+	latestL2Header, err := db.L2LatestBlockHeader()
+	if err != nil {
+		return nil, err
+	} else if latestL2Header == nil {
+		return nil, nil
+	}
+
+	minTime := latestL1Header.Timestamp
+	if latestL2Header.Timestamp < minTime {
+		minTime = latestL2Header.Timestamp
+	}
+
+	// This is a faster query than doing an INNER JOIN between l1_block_headers and l2_block_headers
+	// which requires a full table scan to compute the resulting table.
+	l1Query := db.gorm.Table("l1_block_headers").Where("timestamp <= ?", minTime)
+	l2Query := db.gorm.Table("l2_block_headers").Where("timestamp <= ?", minTime)
+	query := db.gorm.Raw(`SELECT * FROM (?) AS l1_block_headers, (?) AS l2_block_headers
+		WHERE l1_block_headers.timestamp = l2_block_headers.timestamp
+		ORDER BY l2_block_headers.number DESC LIMIT 1`, l1Query, l2Query)
 
 	var epoch Epoch
 	result := query.Take(&epoch)

indexer/database/bridge_messages.go

@@ -72,7 +72,7 @@ func newBridgeMessagesDB(db *gorm.DB) BridgeMessagesDB {
  */
 
 func (db bridgeMessagesDB) StoreL1BridgeMessages(messages []L1BridgeMessage) error {
-	result := db.gorm.Create(&messages)
+	result := db.gorm.CreateInBatches(&messages, batchInsertSize)
 	return result.Error
 }
 
@@ -111,7 +111,7 @@ func (db bridgeMessagesDB) MarkRelayedL1BridgeMessage(messageHash common.Hash, r
  */
 
 func (db bridgeMessagesDB) StoreL2BridgeMessages(messages []L2BridgeMessage) error {
-	result := db.gorm.Create(&messages)
+	result := db.gorm.CreateInBatches(&messages, batchInsertSize)
 	return result.Error
 }
 

indexer/database/bridge_transactions.go

@@ -47,7 +47,10 @@ type L2TransactionWithdrawal struct {
 
 type BridgeTransactionsView interface {
 	L1TransactionDeposit(common.Hash) (*L1TransactionDeposit, error)
+	L1LatestBlockHeader() (*L1BlockHeader, error)
+
 	L2TransactionWithdrawal(common.Hash) (*L2TransactionWithdrawal, error)
+	L2LatestBlockHeader() (*L2BlockHeader, error)
 }
 
 type BridgeTransactionsDB interface {
@@ -77,7 +80,7 @@ func newBridgeTransactionsDB(db *gorm.DB) BridgeTransactionsDB {
  */
 
 func (db *bridgeTransactionsDB) StoreL1TransactionDeposits(deposits []L1TransactionDeposit) error {
-	result := db.gorm.Create(&deposits)
+	result := db.gorm.CreateInBatches(&deposits, batchInsertSize)
 	return result.Error
 }
 
@@ -94,12 +97,43 @@ func (db *bridgeTransactionsDB) L1TransactionDeposit(sourceHash common.Hash) (*L
 	return &deposit, nil
 }
 
+func (db *bridgeTransactionsDB) L1LatestBlockHeader() (*L1BlockHeader, error) {
+	// Markers for an indexed bridge event
+	// L1: Latest Transaction Deposit, Latest Proven/Finalized Withdrawal
+	l1DepositQuery := db.gorm.Table("l1_transaction_deposits").Order("l1_transaction_deposits.timestamp DESC").Limit(1)
+	l1DepositQuery = l1DepositQuery.Joins("INNER JOIN l1_contract_events ON l1_contract_events.guid = l1_transaction_deposits.initiated_l1_event_guid")
+	l1DepositQuery = l1DepositQuery.Select("l1_contract_events.*")
+
+	l1ProvenQuery := db.gorm.Table("l2_transaction_withdrawals")
+	l1ProvenQuery = l1ProvenQuery.Joins("INNER JOIN l1_contract_events ON l1_contract_events.guid = l2_transaction_withdrawals.proven_l1_event_guid")
+	l1ProvenQuery = l1ProvenQuery.Order("l1_contract_events.timestamp DESC").Select("l1_contract_events.*").Limit(1)
+
+	l1FinalizedQuery := db.gorm.Table("l2_transaction_withdrawals")
+	l1FinalizedQuery = l1FinalizedQuery.Joins("INNER JOIN l1_contract_events ON l1_contract_events.guid = l2_transaction_withdrawals.proven_l1_event_guid")
+	l1FinalizedQuery = l1FinalizedQuery.Order("l1_contract_events.timestamp DESC").Select("l1_contract_events.*").Limit(1)
+
+	l1Query := db.gorm.Table("((?) UNION (?) UNION (?)) AS latest_bridge_events", l1DepositQuery.Limit(1), l1ProvenQuery, l1FinalizedQuery)
+	l1Query = l1Query.Joins("INNER JOIN l1_block_headers ON l1_block_headers.hash = latest_bridge_events.block_hash")
+	l1Query = l1Query.Order("latest_bridge_events.timestamp DESC").Select("l1_block_headers.*")
+
+	var l1Header L1BlockHeader
+	result := l1Query.Take(&l1Header)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &l1Header, nil
+}
+
 /**
  * Transactions withdrawn from L2
  */
 
 func (db *bridgeTransactionsDB) StoreL2TransactionWithdrawals(withdrawals []L2TransactionWithdrawal) error {
-	result := db.gorm.Create(&withdrawals)
+	result := db.gorm.CreateInBatches(&withdrawals, batchInsertSize)
 	return result.Error
 }
 
@@ -149,3 +183,49 @@ func (db *bridgeTransactionsDB) MarkL2TransactionWithdrawalFinalizedEvent(withdr
 	result := db.gorm.Save(&withdrawal)
 	return result.Error
 }
+
+func (db *bridgeTransactionsDB) L2LatestBlockHeader() (*L2BlockHeader, error) {
+	// L2: Latest Withdrawal, Latest L2 Header of indexed deposit epoch
+	var latestWithdrawalHeader, latestL2DepositHeader *L2BlockHeader
+
+	var withdrawHeader L2BlockHeader
+	withdrawalQuery := db.gorm.Table("l2_transaction_withdrawals").Order("timestamp DESC").Limit(1)
+	withdrawalQuery = withdrawalQuery.Joins("INNER JOIN l2_contract_events ON l2_contract_events.guid = l2_transaction_withdrawals.initiated_l2_event_guid")
+	withdrawalQuery = withdrawalQuery.Joins("INNER JOIN l2_block_headers ON l2_block_headers.hash = l2_contract_events.block_hash")
+	result := withdrawalQuery.Select("l2_block_headers.*").Take(&withdrawHeader)
+	if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) {
+		return nil, result.Error
+	} else if !errors.Is(result.Error, gorm.ErrRecordNotFound) {
+		latestWithdrawalHeader = &withdrawHeader
+	}
+
+	// Check for any deposits that may have been included after the latest withdrawal. However, since the bridge
+	// processor only inserts entries when the corresponding epoch has been indexed on both L1 and L2, we can
+	// simply look for the latest L2 block with at <= time of the latest L1 deposit.
+	var l1Deposit L1TransactionDeposit
+	result = db.gorm.Table("l1_transaction_deposits").Order("timestamp DESC").Limit(1).Take(&l1Deposit)
+	if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) {
+		return nil, result.Error
+	} else if !errors.Is(result.Error, gorm.ErrRecordNotFound) {
+		var l2DepositHeader L2BlockHeader
+		result := db.gorm.Table("l2_block_headers").Order("timestamp DESC").Limit(1).Where("timestamp <= ?", l1Deposit.Tx.Timestamp).Take(&l2DepositHeader)
+		if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, result.Error
+		} else if !errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			latestL2DepositHeader = &l2DepositHeader
+		}
+	}
+
+	// compare
+	if latestWithdrawalHeader == nil {
+		return latestL2DepositHeader, nil
+	} else if latestL2DepositHeader == nil {
+		return latestWithdrawalHeader, nil
+	}
+
+	if latestWithdrawalHeader.Timestamp >= latestL2DepositHeader.Timestamp {
+		return latestWithdrawalHeader, nil
+	} else {
+		return latestL2DepositHeader, nil
+	}
+}

indexer/database/bridge_transfers.go

@@ -89,7 +89,7 @@ func newBridgeTransfersDB(db *gorm.DB) BridgeTransfersDB {
  */
 
 func (db *bridgeTransfersDB) StoreL1BridgeDeposits(deposits []L1BridgeDeposit) error {
-	result := db.gorm.Create(&deposits)
+	result := db.gorm.CreateInBatches(&deposits, batchInsertSize)
 	return result.Error
 }
 
@@ -202,7 +202,7 @@ l1_bridge_deposits.timestamp, cross_domain_message_hash, local_token_address, re
  */
 
 func (db *bridgeTransfersDB) StoreL2BridgeWithdrawals(withdrawals []L2BridgeWithdrawal) error {
-	result := db.gorm.Create(&withdrawals)
+	result := db.gorm.CreateInBatches(&withdrawals, batchInsertSize)
 	return result.Error
 }
 

indexer/database/contract_events.go

@@ -109,7 +109,7 @@ func newContractEventsDB(db *gorm.DB) ContractEventsDB {
 // L1
 
 func (db *contractEventsDB) StoreL1ContractEvents(events []L1ContractEvent) error {
-	result := db.gorm.Create(&events)
+	result := db.gorm.CreateInBatches(&events, batchInsertSize)
 	return result.Error
 }
 
@@ -176,7 +176,7 @@ func (db *contractEventsDB) L1LatestContractEventWithFilter(filter ContractEvent
 // L2
 
 func (db *contractEventsDB) StoreL2ContractEvents(events []L2ContractEvent) error {
-	result := db.gorm.Create(&events)
+	result := db.gorm.CreateInBatches(&events, batchInsertSize)
 	return result.Error
 }
 

indexer/database/db.go

@@ -12,6 +12,14 @@ import (
 	"gorm.io/gorm/logger"
 )
 
+var (
+	// The postgres parameter counter for a given query is stored via a  uint16,
+	// resulting in a parameter limit of 65535. In order to avoid reaching this limit
+	// we'll utilize a batch size of 3k for inserts, well below as long as the the number
+	// of columns < 20.
+	batchInsertSize int = 3_000
+)
+
 type DB struct {
 	gorm *gorm.DB
 
@@ -31,8 +39,7 @@ func NewDB(dbConfig config.DBConfig) (*DB, error) {
 		dsn += fmt.Sprintf(" password=%s", dbConfig.Password)
 	}
 	gorm, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
-		// The indexer will explicitly manage the transaction
-		// flow processing blocks
+		// The indexer will explicitly manage the transactions
 		SkipDefaultTransaction: true,
 
 		// We may choose to create an adapter such that the

indexer/database/mocks.go

@@ -4,6 +4,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
+
 	"github.com/stretchr/testify/mock"
 )
 

indexer/etl/l1_etl.go

@@ -44,7 +44,7 @@ func NewL1ETL(cfg Config, log log.Logger, db *database.DB, metrics Metricer, cli
 		fromHeader = latestHeader.RLPHeader.Header()
 
 	} else if cfg.StartHeight.BitLen() > 0 {
-		log.Info("no indexed state in storage, starting from supplied L1 height", "height", cfg.StartHeight.String())
+		log.Info("no indexed state starting from supplied L1 height", "height", cfg.StartHeight.String())
 		header, err := client.BlockHeaderByNumber(cfg.StartHeight)
 		if err != nil {
 			return nil, fmt.Errorf("could not fetch starting block header: %w", err)
@@ -53,7 +53,7 @@ func NewL1ETL(cfg Config, log log.Logger, db *database.DB, metrics Metricer, cli
 		fromHeader = header
 
 	} else {
-		log.Info("no indexed state in storage, starting from L1 genesis")
+		log.Info("no indexed state, starting from genesis")
 	}
 
 	// NOTE - The use of un-buffered channel here assumes that downstream consumers

indexer/etl/l1_etl_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
+	"github.com/ethereum-optimism/optimism/indexer/bigint"
 	"github.com/ethereum-optimism/optimism/indexer/config"
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/indexer/node"
@@ -17,7 +18,7 @@ import (
 	"testing"
 )
 
-func Test_L1ETL_Construction(t *testing.T) {
+func TestL1ETLConstruction(t *testing.T) {
 	etlMetrics := NewMetrics(metrics.NewRegistry(), "l1")
 
 	type testSuite struct {
@@ -39,11 +40,10 @@ func Test_L1ETL_Construction(t *testing.T) {
 				db := database.NewMockDB()
 
 				testStart := big.NewInt(100)
-
 				db.MockBlocks.On("L1LatestBlockHeader").Return(nil, nil)
 
 				client.On("BlockHeaderByNumber", mock.MatchedBy(
-					node.BigIntMatcher(100))).Return(
+					bigint.Matcher(100))).Return(
 					&types.Header{
 						ParentHash: common.HexToHash("0x69"),
 					}, nil)

indexer/indexer.toml

@@ -3,7 +3,7 @@
 [chain]
 
 # OP Goerli
-preset = 420
+preset = $INDEXER_CHAIN_PRESET
 
 # L1 Config
 l1-polling-interval = 0
@@ -22,11 +22,15 @@ l1-rpc = "${INDEXER_RPC_URL_L1}"
 l2-rpc = "${INDEXER_RPC_URL_L2}"
 
 [db]
-host = "postgres"
-port = 5432
-user = "db_username"
-password = "db_password"
-name = "db_name"
+host = "$INDEXER_DB_HOST"
+# this port may be problematic once we depoly
+# the DATABASE_URL looks like this for previous services and didn't include a port
+# DATABASE_URL="postgresql://${INDEXER_DB_USER}:${INDEXER_DB_PASS}@localhost/${INDEXER_DB_NAME}?host=${INDEXER_DB_HOST}"
+# If not problematic delete these comments
+port = $INDEXER_DB_PORT
+user = "$INDEXER_DB_USER"
+password = "$INDEXER_DB_PASS"
+name = "$INDEXER_DB_NAME"
 
 [http]
 host = "127.0.0.1"

indexer/migrations/20230523_create_schema.sql

 
-CREATE DOMAIN UINT256 AS NUMERIC
-    CHECK (VALUE >= 0 AND VALUE < 2^256 and SCALE(VALUE) = 0);
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'uint256') THEN
+        CREATE DOMAIN UINT256 AS NUMERIC
+            CHECK (VALUE >= 0 AND VALUE < 2^256 and SCALE(VALUE) = 0);
+    END IF;
+END $$;
 
 /**
  * BLOCK DATA
@@ -16,6 +21,8 @@ CREATE TABLE IF NOT EXISTS l1_block_headers (
     -- Raw Data
     rlp_bytes VARCHAR NOT NULL
 );
+CREATE INDEX IF NOT EXISTS l1_block_headers_timestamp ON l1_block_headers(timestamp);
+CREATE INDEX IF NOT EXISTS l1_block_headers_number ON l1_block_headers(number);
 
 CREATE TABLE IF NOT EXISTS l2_block_headers (
     -- Searchable fields
@@ -27,6 +34,8 @@ CREATE TABLE IF NOT EXISTS l2_block_headers (
     -- Raw Data
     rlp_bytes VARCHAR NOT NULL
 );
+CREATE INDEX IF NOT EXISTS l2_block_headers_timestamp ON l2_block_headers(timestamp);
+CREATE INDEX IF NOT EXISTS l2_block_headers_number ON l2_block_headers(number);
 
 /**
  * EVENT DATA
@@ -45,6 +54,9 @@ CREATE TABLE IF NOT EXISTS l1_contract_events (
     -- Raw Data
     rlp_bytes VARCHAR NOT NULL
 );
+CREATE INDEX IF NOT EXISTS l1_contract_events_timestamp ON l1_contract_events(timestamp);
+CREATE INDEX IF NOT EXISTS l1_contract_events_block_hash ON l1_contract_events(block_hash);
+CREATE INDEX IF NOT EXISTS l1_contract_events_event_signature ON l1_contract_events(event_signature);
 
 CREATE TABLE IF NOT EXISTS l2_contract_events (
     -- Searchable fields
@@ -59,6 +71,9 @@ CREATE TABLE IF NOT EXISTS l2_contract_events (
     -- Raw Data
     rlp_bytes VARCHAR NOT NULL
 );
+CREATE INDEX IF NOT EXISTS l2_contract_events_timestamp ON l2_contract_events(timestamp);
+CREATE INDEX IF NOT EXISTS l2_contract_events_block_hash ON l2_contract_events(block_hash);
+CREATE INDEX IF NOT EXISTS l2_contract_events_event_signature ON l2_contract_events(event_signature);
 
 -- Tables that index finalization markers for L2 blocks.
 
@@ -79,6 +94,7 @@ CREATE TABLE IF NOT EXISTS output_proposals (
     output_proposed_guid VARCHAR NOT NULL UNIQUE REFERENCES l1_contract_events(guid) ON DELETE CASCADE
 );
 
+
 /**
  * BRIDGING DATA
  */
@@ -118,6 +134,10 @@ CREATE TABLE IF NOT EXISTS l1_transaction_deposits (
     data         VARCHAR NOT NULL,
     timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
 );
+CREATE INDEX IF NOT EXISTS l1_transaction_deposits_timestamp ON l1_transaction_deposits(timestamp);
+CREATE INDEX IF NOT EXISTS l1_transaction_deposits_initiated_l1_event_guid ON l1_transaction_deposits(initiated_l1_event_guid);
+CREATE INDEX IF NOT EXISTS l1_transaction_deposits_from_address ON l1_transaction_deposits(from_address);
+
 CREATE TABLE IF NOT EXISTS l2_transaction_withdrawals (
     withdrawal_hash         VARCHAR PRIMARY KEY,
     nonce                   UINT256 NOT NULL UNIQUE,
@@ -136,6 +156,9 @@ CREATE TABLE IF NOT EXISTS l2_transaction_withdrawals (
     data         VARCHAR NOT NULL,
     timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
 );
+CREATE INDEX IF NOT EXISTS l2_transaction_withdrawals_timestamp ON l2_transaction_withdrawals(timestamp);
+CREATE INDEX IF NOT EXISTS l2_transaction_withdrawals_initiated_l2_event_guid ON l2_transaction_withdrawals(initiated_l2_event_guid);
+CREATE INDEX IF NOT EXISTS l2_transaction_withdrawals_from_address ON l2_transaction_withdrawals(from_address);
 
 -- CrossDomainMessenger
 CREATE TABLE IF NOT EXISTS l1_bridge_messages(
@@ -154,6 +177,10 @@ CREATE TABLE IF NOT EXISTS l1_bridge_messages(
     data         VARCHAR NOT NULL,
     timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
 );
+CREATE INDEX IF NOT EXISTS l1_bridge_messages_timestamp ON l1_bridge_messages(timestamp);
+CREATE INDEX IF NOT EXISTS l1_bridge_messages_transaction_source_hash ON l1_bridge_messages(transaction_source_hash);
+CREATE INDEX IF NOT EXISTS l1_bridge_messages_from_address ON l1_bridge_messages(from_address);
+
 CREATE TABLE IF NOT EXISTS l2_bridge_messages(
     message_hash                VARCHAR PRIMARY KEY,
     nonce                       UINT256 NOT NULL UNIQUE,
@@ -170,6 +197,9 @@ CREATE TABLE IF NOT EXISTS l2_bridge_messages(
     data         VARCHAR NOT NULL,
     timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
 );
+CREATE INDEX IF NOT EXISTS l2_bridge_messages_timestamp ON l2_bridge_messages(timestamp);
+CREATE INDEX IF NOT EXISTS l2_bridge_messages_transaction_withdrawal_hash ON l2_bridge_messages(transaction_withdrawal_hash);
+CREATE INDEX IF NOT EXISTS l2_bridge_messages_from_address ON l2_bridge_messages(from_address);
 
 -- StandardBridge
 CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
@@ -185,6 +215,10 @@ CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
     data                 VARCHAR NOT NULL,
     timestamp            INTEGER NOT NULL CHECK (timestamp > 0)
 );
+CREATE INDEX IF NOT EXISTS l1_bridge_deposits_timestamp ON l1_bridge_deposits(timestamp);
+CREATE INDEX IF NOT EXISTS l1_bridge_deposits_cross_domain_message_hash ON l1_bridge_deposits(cross_domain_message_hash);
+CREATE INDEX IF NOT EXISTS l1_bridge_deposits_from_address ON l1_bridge_deposits(from_address);
+
 CREATE TABLE IF NOT EXISTS l2_bridge_withdrawals (
     transaction_withdrawal_hash VARCHAR PRIMARY KEY REFERENCES l2_transaction_withdrawals(withdrawal_hash) ON DELETE CASCADE,
     cross_domain_message_hash   VARCHAR NOT NULL UNIQUE REFERENCES l2_bridge_messages(message_hash) ON DELETE CASCADE,
@@ -198,3 +232,6 @@ CREATE TABLE IF NOT EXISTS l2_bridge_withdrawals (
     data                 VARCHAR NOT NULL,
     timestamp            INTEGER NOT NULL CHECK (timestamp > 0)
 );
+CREATE INDEX IF NOT EXISTS l2_bridge_withdrawals_timestamp ON l2_bridge_withdrawals(timestamp);
+CREATE INDEX IF NOT EXISTS l2_bridge_withdrawals_cross_domain_message_hash ON l2_bridge_withdrawals(cross_domain_message_hash);
+CREATE INDEX IF NOT EXISTS l2_bridge_withdrawals_from_address ON l2_bridge_withdrawals(from_address);

indexer/node/bigint.go

-package node
-
-import "math/big"
-
-var bigZero = big.NewInt(0)
-var bigOne = big.NewInt(1)
-
-// returns a new big.Int for `end` to which `end - start` <= size.
-// @note (start, end) is an inclusive range
-func clampBigInt(start, end *big.Int, size uint64) *big.Int {
-	temp := new(big.Int)
-
-	count := temp.Sub(end, start).Uint64() + 1
-	if count <= size {
-		return end
-	}
-
-	// we re-use the allocated temp as the new end
-	temp.Add(start, big.NewInt(int64(size-1)))
-	return temp
-}
-
-// returns an inner comparison function result for a big.Int
-func BigIntMatcher(num int64) func(*big.Int) bool {
-	return func(bi *big.Int) bool { return bi.Int64() == num }
-}

indexer/node/bigint_test.go

-package node
-
-import (
-	"math/big"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestClampBigInt(t *testing.T) {
-	assert.True(t, true)
-
-	start := big.NewInt(1)
-	end := big.NewInt(10)
-
-	// When the (start, end) bounds are within range
-	// the same end pointer should be returned
-
-	// larger range
-	result := clampBigInt(start, end, 20)
-	assert.True(t, end == result)
-
-	// exact range
-	result = clampBigInt(start, end, 10)
-	assert.True(t, end == result)
-
-	// smaller range
-	result = clampBigInt(start, end, 5)
-	assert.False(t, end == result)
-	assert.Equal(t, uint64(5), result.Uint64())
-}

indexer/node/header_traversal.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum-optimism/optimism/indexer/bigint"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
@@ -55,12 +56,12 @@ func (f *HeaderTraversal) NextFinalizedHeaders(maxSize uint64) ([]types.Header,
 		}
 	}
 
-	nextHeight := bigZero
+	nextHeight := bigint.Zero
 	if f.lastHeader != nil {
-		nextHeight = new(big.Int).Add(f.lastHeader.Number, bigOne)
+		nextHeight = new(big.Int).Add(f.lastHeader.Number, bigint.One)
 	}
 
-	endHeight = clampBigInt(nextHeight, endHeight, maxSize)
+	endHeight = bigint.Clamp(nextHeight, endHeight, maxSize)
 	headers, err := f.ethClient.BlockHeadersByRange(nextHeight, endHeight)
 	if err != nil {
 		return nil, fmt.Errorf("error querying blocks by range: %w", err)

indexer/node/header_traversal_test.go

@@ -4,6 +4,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/indexer/bigint"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
@@ -37,7 +38,7 @@ func TestHeaderTraversalNextFinalizedHeadersNoOp(t *testing.T) {
 
 	// start from block 10 as the latest fetched block
 	lastHeader := &types.Header{Number: big.NewInt(10)}
-	headerTraversal := NewHeaderTraversal(client, lastHeader, bigZero)
+	headerTraversal := NewHeaderTraversal(client, lastHeader, bigint.Zero)
 
 	// no new headers when matched with head
 	client.On("BlockHeaderByNumber", (*big.Int)(nil)).Return(lastHeader, nil)
@@ -50,12 +51,12 @@ func TestHeaderTraversalNextFinalizedHeadersCursored(t *testing.T) {
 	client := new(MockEthClient)
 
 	// start from genesis
-	headerTraversal := NewHeaderTraversal(client, nil, bigZero)
+	headerTraversal := NewHeaderTraversal(client, nil, bigint.Zero)
 
 	// blocks [0..4]
 	headers := makeHeaders(5, nil)
 	client.On("BlockHeaderByNumber", (*big.Int)(nil)).Return(&headers[4], nil).Times(1) // Times so that we can override next
-	client.On("BlockHeadersByRange", mock.MatchedBy(BigIntMatcher(0)), mock.MatchedBy(BigIntMatcher(4))).Return(headers, nil)
+	client.On("BlockHeadersByRange", mock.MatchedBy(bigint.Matcher(0)), mock.MatchedBy(bigint.Matcher(4))).Return(headers, nil)
 	headers, err := headerTraversal.NextFinalizedHeaders(5)
 	require.NoError(t, err)
 	require.Len(t, headers, 5)
@@ -63,7 +64,7 @@ func TestHeaderTraversalNextFinalizedHeadersCursored(t *testing.T) {
 	// blocks [5..9]
 	headers = makeHeaders(5, &headers[len(headers)-1])
 	client.On("BlockHeaderByNumber", (*big.Int)(nil)).Return(&headers[4], nil)
-	client.On("BlockHeadersByRange", mock.MatchedBy(BigIntMatcher(5)), mock.MatchedBy(BigIntMatcher(9))).Return(headers, nil)
+	client.On("BlockHeadersByRange", mock.MatchedBy(bigint.Matcher(5)), mock.MatchedBy(bigint.Matcher(9))).Return(headers, nil)
 	headers, err = headerTraversal.NextFinalizedHeaders(5)
 	require.NoError(t, err)
 	require.Len(t, headers, 5)
@@ -73,21 +74,21 @@ func TestHeaderTraversalNextFinalizedHeadersMaxSize(t *testing.T) {
 	client := new(MockEthClient)
 
 	// start from genesis
-	headerTraversal := NewHeaderTraversal(client, nil, bigZero)
+	headerTraversal := NewHeaderTraversal(client, nil, bigint.Zero)
 
 	// 100 "available" headers
 	client.On("BlockHeaderByNumber", (*big.Int)(nil)).Return(&types.Header{Number: big.NewInt(100)}, nil)
 
 	// clamped by the supplied size
 	headers := makeHeaders(5, nil)
-	client.On("BlockHeadersByRange", mock.MatchedBy(BigIntMatcher(0)), mock.MatchedBy(BigIntMatcher(4))).Return(headers, nil)
+	client.On("BlockHeadersByRange", mock.MatchedBy(bigint.Matcher(0)), mock.MatchedBy(bigint.Matcher(4))).Return(headers, nil)
 	headers, err := headerTraversal.NextFinalizedHeaders(5)
 	require.NoError(t, err)
 	require.Len(t, headers, 5)
 
 	// clamped by the supplied size. FinalizedHeight == 100
 	headers = makeHeaders(10, &headers[len(headers)-1])
-	client.On("BlockHeadersByRange", mock.MatchedBy(BigIntMatcher(5)), mock.MatchedBy(BigIntMatcher(14))).Return(headers, nil)
+	client.On("BlockHeadersByRange", mock.MatchedBy(bigint.Matcher(5)), mock.MatchedBy(bigint.Matcher(14))).Return(headers, nil)
 	headers, err = headerTraversal.NextFinalizedHeaders(10)
 	require.NoError(t, err)
 	require.Len(t, headers, 10)
@@ -97,12 +98,12 @@ func TestHeaderTraversalMismatchedProviderStateError(t *testing.T) {
 	client := new(MockEthClient)
 
 	// start from genesis
-	headerTraversal := NewHeaderTraversal(client, nil, bigZero)
+	headerTraversal := NewHeaderTraversal(client, nil, bigint.Zero)
 
 	// blocks [0..4]
 	headers := makeHeaders(5, nil)
 	client.On("BlockHeaderByNumber", (*big.Int)(nil)).Return(&headers[4], nil).Times(1) // Times so that we can override next
-	client.On("BlockHeadersByRange", mock.MatchedBy(BigIntMatcher(0)), mock.MatchedBy(BigIntMatcher(4))).Return(headers, nil)
+	client.On("BlockHeadersByRange", mock.MatchedBy(bigint.Matcher(0)), mock.MatchedBy(bigint.Matcher(4))).Return(headers, nil)
 	headers, err := headerTraversal.NextFinalizedHeaders(5)
 	require.NoError(t, err)
 	require.Len(t, headers, 5)
@@ -110,7 +111,7 @@ func TestHeaderTraversalMismatchedProviderStateError(t *testing.T) {
 	// blocks [5..9]. Next batch is not chained correctly (starts again from genesis)
 	headers = makeHeaders(5, nil)
 	client.On("BlockHeaderByNumber", (*big.Int)(nil)).Return(&types.Header{Number: big.NewInt(9)}, nil)
-	client.On("BlockHeadersByRange", mock.MatchedBy(BigIntMatcher(5)), mock.MatchedBy(BigIntMatcher(9))).Return(headers, nil)
+	client.On("BlockHeadersByRange", mock.MatchedBy(bigint.Matcher(5)), mock.MatchedBy(bigint.Matcher(9))).Return(headers, nil)
 	headers, err = headerTraversal.NextFinalizedHeaders(5)
 	require.Nil(t, headers)
 	require.Equal(t, ErrHeaderTraversalAndProviderMismatchedState, err)

indexer/node/mocks.go

@@ -6,6 +6,7 @@ import (
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+
 	"github.com/stretchr/testify/mock"
 )
 

op-batcher/Dockerfile

@@ -4,21 +4,24 @@ ARG VERSION=v0.0.0
 
 RUN apk add --no-cache make gcc musl-dev linux-headers git jq bash
 
+COPY ./go.mod /app/go.mod
+COPY ./go.sum /app/go.sum
+
+WORKDIR /app
+
+RUN go mod download
+
 # build op-batcher with the shared go.mod & go.sum files
 COPY ./op-batcher /app/op-batcher
 COPY ./op-bindings /app/op-bindings
 COPY ./op-node /app/op-node
 COPY ./op-service /app/op-service
 COPY ./op-signer /app/op-signer
-COPY ./go.mod /app/go.mod
-COPY ./go.sum /app/go.sum
 
 COPY ./.git /app/.git
 
 WORKDIR /app/op-batcher
 
-RUN go mod download
-
 ARG TARGETOS TARGETARCH
 
 RUN make op-batcher VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH

op-bindings/Makefile

@@ -12,6 +12,7 @@ version:
 
 compile:
 	cd $(contracts-dir) && \
+		forge clean && \
 		pnpm build
 
 bindings: compile bindings-build

op-bindings/bindings/alphabetvm_more.go

@@ -13,7 +13,7 @@ const AlphabetVMStorageLayoutJSON = "{\"storage\":[{\"astId\":1000,\"contract\":
 
 var AlphabetVMStorageLayout = new(solc.StorageLayout)
 
-var AlphabetVMDeployedBin = "0x608060405234801561001057600080fd5b50600436106100365760003560e01c80637dc0d1d01461003b578063f8e0cb9614610085575b600080fd5b60005461005b9073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b6100986100933660046101a8565b6100a6565b60405190815260200161007c565b60008060007f000000000000000000000000000000000000000000000000000000000000000087876040516100dc929190610214565b60405180910390200361010057600091506100f986880188610224565b905061011f565b61010c8688018861023d565b90925090508161011b8161028e565b9250505b8161012b8260016102c6565b6040805160208101939093528201526060016040516020818303038152906040528051906020012092505050949350505050565b60008083601f84011261017157600080fd5b50813567ffffffffffffffff81111561018957600080fd5b6020830191508360208285010111156101a157600080fd5b9250929050565b600080600080604085870312156101be57600080fd5b843567ffffffffffffffff808211156101d657600080fd5b6101e28883890161015f565b909650945060208701359150808211156101fb57600080fd5b506102088782880161015f565b95989497509550505050565b8183823760009101908152919050565b60006020828403121561023657600080fd5b5035919050565b6000806040838503121561025057600080fd5b50508035926020909101359150565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036102bf576102bf61025f565b5060010190565b600082198211156102d9576102d961025f565b50019056fea164736f6c634300080f000a"
+var AlphabetVMDeployedBin = "0x608060405234801561001057600080fd5b50600436106100365760003560e01c80637dc0d1d01461003b578063f8e0cb9614610085575b600080fd5b60005461005b9073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b610098610093366004610212565b6100a6565b60405190815260200161007c565b600080600060087f0000000000000000000000000000000000000000000000000000000000000000901b600888886040516100e292919061027e565b6040518091039020901b0361010857600091506101018688018861028e565b9050610127565b610114868801886102a7565b909250905081610123816102f8565b9250505b81610133826001610330565b604080516020810193909352820152606001604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe081840301815291905280516020909101207effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f010000000000000000000000000000000000000000000000000000000000000017979650505050505050565b60008083601f8401126101db57600080fd5b50813567ffffffffffffffff8111156101f357600080fd5b60208301915083602082850101111561020b57600080fd5b9250929050565b6000806000806040858703121561022857600080fd5b843567ffffffffffffffff8082111561024057600080fd5b61024c888389016101c9565b9096509450602087013591508082111561026557600080fd5b50610272878288016101c9565b95989497509550505050565b8183823760009101908152919050565b6000602082840312156102a057600080fd5b5035919050565b600080604083850312156102ba57600080fd5b50508035926020909101359150565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203610329576103296102c9565b5060010190565b60008219821115610343576103436102c9565b50019056fea164736f6c634300080f000a"
 
 func init() {
 	if err := json.Unmarshal([]byte(AlphabetVMStorageLayoutJSON), AlphabetVMStorageLayout); err != nil {

op-challenger/Dockerfile

@@ -4,6 +4,13 @@ ARG VERSION=v0.0.0
 
 RUN apk add --no-cache make gcc musl-dev linux-headers git jq bash
 
+COPY ./go.mod /app/go.mod
+COPY ./go.sum /app/go.sum
+
+WORKDIR /app
+
+RUN go mod download
+
 # build op-challenger with the shared go.mod & go.sum files
 COPY ./op-challenger /app/op-challenger
 COPY ./op-program /app/op-program
@@ -12,8 +19,6 @@ COPY ./op-bindings /app/op-bindings
 COPY ./op-node /app/op-node
 COPY ./op-service /app/op-service
 COPY ./op-signer /app/op-signer
-COPY ./go.mod /app/go.mod
-COPY ./go.sum /app/go.sum
 COPY ./.git /app/.git
 
 # Copy cannon and its dependencies
@@ -23,8 +28,6 @@ COPY ./op-chain-ops /app/op-chain-ops
 
 WORKDIR /app/op-program
 
-RUN go mod download
-
 ARG TARGETOS TARGETARCH
 
 RUN make op-program-host VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH

op-challenger/game/fault/agent.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/solver"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum/go-ethereum/log"
 )
@@ -14,7 +15,7 @@ import (
 // Responder takes a response action & executes.
 // For full op-challenger this means executing the transaction on chain.
 type Responder interface {
-	CallResolve(ctx context.Context) (types.GameStatus, error)
+	CallResolve(ctx context.Context) (gameTypes.GameStatus, error)
 	Resolve(ctx context.Context) error
 	Respond(ctx context.Context, response types.Claim) error
 	Step(ctx context.Context, stepData types.StepCallData) error
@@ -74,10 +75,10 @@ func (a *Agent) Act(ctx context.Context) error {
 
 // shouldResolve returns true if the agent should resolve the game.
 // This method will return false if the game is still in progress.
-func (a *Agent) shouldResolve(status types.GameStatus) bool {
-	expected := types.GameStatusDefenderWon
+func (a *Agent) shouldResolve(status gameTypes.GameStatus) bool {
+	expected := gameTypes.GameStatusDefenderWon
 	if a.agreeWithProposedOutput {
-		expected = types.GameStatusChallengerWon
+		expected = gameTypes.GameStatusChallengerWon
 	}
 	if expected != status {
 		a.log.Warn("Game will be lost", "expected", expected, "actual", status)
@@ -89,7 +90,7 @@ func (a *Agent) shouldResolve(status types.GameStatus) bool {
 // Returns true if the game is resolvable (regardless of whether it was actually resolved)
 func (a *Agent) tryResolve(ctx context.Context) bool {
 	status, err := a.responder.CallResolve(ctx)
-	if err != nil || status == types.GameStatusInProgress {
+	if err != nil || status == gameTypes.GameStatusInProgress {
 		return false
 	}
 	if !a.shouldResolve(status) {

op-challenger/game/fault/agent_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/test"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/alphabet"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
@@ -19,16 +20,16 @@ import (
 func TestShouldResolve(t *testing.T) {
 	t.Run("AgreeWithProposedOutput", func(t *testing.T) {
 		agent, _, _ := setupTestAgent(t, true)
-		require.False(t, agent.shouldResolve(types.GameStatusDefenderWon))
-		require.True(t, agent.shouldResolve(types.GameStatusChallengerWon))
-		require.False(t, agent.shouldResolve(types.GameStatusInProgress))
+		require.False(t, agent.shouldResolve(gameTypes.GameStatusDefenderWon))
+		require.True(t, agent.shouldResolve(gameTypes.GameStatusChallengerWon))
+		require.False(t, agent.shouldResolve(gameTypes.GameStatusInProgress))
 	})
 
 	t.Run("DisagreeWithProposedOutput", func(t *testing.T) {
 		agent, _, _ := setupTestAgent(t, false)
-		require.True(t, agent.shouldResolve(types.GameStatusDefenderWon))
-		require.False(t, agent.shouldResolve(types.GameStatusChallengerWon))
-		require.False(t, agent.shouldResolve(types.GameStatusInProgress))
+		require.True(t, agent.shouldResolve(gameTypes.GameStatusDefenderWon))
+		require.False(t, agent.shouldResolve(gameTypes.GameStatusChallengerWon))
+		require.False(t, agent.shouldResolve(gameTypes.GameStatusInProgress))
 	})
 }
 
@@ -38,31 +39,31 @@ func TestDoNotMakeMovesWhenGameIsResolvable(t *testing.T) {
 	tests := []struct {
 		name                    string
 		agreeWithProposedOutput bool
-		callResolveStatus       types.GameStatus
+		callResolveStatus       gameTypes.GameStatus
 		shouldResolve           bool
 	}{
 		{
 			name:                    "Agree_Losing",
 			agreeWithProposedOutput: true,
-			callResolveStatus:       types.GameStatusDefenderWon,
+			callResolveStatus:       gameTypes.GameStatusDefenderWon,
 			shouldResolve:           false,
 		},
 		{
 			name:                    "Agree_Winning",
 			agreeWithProposedOutput: true,
-			callResolveStatus:       types.GameStatusChallengerWon,
+			callResolveStatus:       gameTypes.GameStatusChallengerWon,
 			shouldResolve:           true,
 		},
 		{
 			name:                    "Disagree_Losing",
 			agreeWithProposedOutput: false,
-			callResolveStatus:       types.GameStatusChallengerWon,
+			callResolveStatus:       gameTypes.GameStatusChallengerWon,
 			shouldResolve:           false,
 		},
 		{
 			name:                    "Disagree_Winning",
 			agreeWithProposedOutput: false,
-			callResolveStatus:       types.GameStatusDefenderWon,
+			callResolveStatus:       gameTypes.GameStatusDefenderWon,
 			shouldResolve:           true,
 		},
 	}
@@ -126,14 +127,14 @@ func (s *stubClaimLoader) FetchClaims(ctx context.Context) ([]types.Claim, error
 
 type stubResponder struct {
 	callResolveCount  int
-	callResolveStatus types.GameStatus
+	callResolveStatus gameTypes.GameStatus
 	callResolveErr    error
 
 	resolveCount int
 	resolveErr   error
 }
 
-func (s *stubResponder) CallResolve(ctx context.Context) (types.GameStatus, error) {
+func (s *stubResponder) CallResolve(ctx context.Context) (gameTypes.GameStatus, error) {
 	s.callResolveCount++
 	return s.callResolveStatus, s.callResolveErr
 }

op-challenger/game/fault/loader.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -49,9 +50,9 @@ func NewLoaderFromBindings(fdgAddr common.Address, client bind.ContractCaller) (
 }
 
 // GetGameStatus returns the current game status.
-func (l *loader) GetGameStatus(ctx context.Context) (types.GameStatus, error) {
+func (l *loader) GetGameStatus(ctx context.Context) (gameTypes.GameStatus, error) {
 	status, err := l.caller.Status(&bind.CallOpts{Context: ctx})
-	return types.GameStatus(status), err
+	return gameTypes.GameStatus(status), err
 }
 
 // GetClaimCount returns the number of claims in the game.
@@ -138,16 +139,15 @@ func (l *loader) FetchClaims(ctx context.Context) ([]types.Claim, error) {
 }
 
 // FetchAbsolutePrestateHash fetches the hashed absolute prestate from the fault dispute game.
-func (l *loader) FetchAbsolutePrestateHash(ctx context.Context) ([]byte, error) {
+func (l *loader) FetchAbsolutePrestateHash(ctx context.Context) (common.Hash, error) {
 	callOpts := bind.CallOpts{
 		Context: ctx,
 	}
 
 	absolutePrestate, err := l.caller.ABSOLUTEPRESTATE(&callOpts)
 	if err != nil {
-		return nil, err
+		return common.Hash{}, err
 	}
-	returnValue := absolutePrestate[:]
 
-	return returnValue, nil
+	return absolutePrestate, nil
 }

op-challenger/game/fault/loader_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -30,15 +31,15 @@ func TestLoader_GetGameStatus(t *testing.T) {
 	}{
 		{
 			name:   "challenger won status",
-			status: uint8(types.GameStatusChallengerWon),
+			status: uint8(gameTypes.GameStatusChallengerWon),
 		},
 		{
 			name:   "defender won status",
-			status: uint8(types.GameStatusDefenderWon),
+			status: uint8(gameTypes.GameStatusDefenderWon),
 		},
 		{
 			name:   "in progress status",
-			status: uint8(types.GameStatusInProgress),
+			status: uint8(gameTypes.GameStatusInProgress),
 		},
 		{
 			name:          "error bubbled up",
@@ -57,7 +58,7 @@ func TestLoader_GetGameStatus(t *testing.T) {
 				require.ErrorIs(t, err, mockStatusError)
 			} else {
 				require.NoError(t, err)
-				require.Equal(t, types.GameStatus(test.status), status)
+				require.Equal(t, gameTypes.GameStatus(test.status), status)
 			}
 		})
 	}

op-challenger/game/fault/player.go

@@ -11,18 +11,18 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/alphabet"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/cannon"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 	"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/log"
 )
 
 type actor func(ctx context.Context) error
 
 type GameInfo interface {
-	GetGameStatus(context.Context) (types.GameStatus, error)
+	GetGameStatus(context.Context) (gameTypes.GameStatus, error)
 	GetClaimCount(context.Context) (uint64, error)
 }
 
@@ -31,8 +31,7 @@ type GamePlayer struct {
 	agreeWithProposedOutput bool
 	loader                  GameInfo
 	logger                  log.Logger
-
-	completed bool
+	status                  gameTypes.GameStatus
 }
 
 func NewGamePlayer(
@@ -57,14 +56,14 @@ func NewGamePlayer(
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch game status: %w", err)
 	}
-	if status != types.GameStatusInProgress {
+	if status != gameTypes.GameStatusInProgress {
 		logger.Info("Game already resolved", "status", status)
 		// Game is already complete so skip creating the trace provider, loading game inputs etc.
 		return &GamePlayer{
 			logger:                  logger,
 			loader:                  loader,
 			agreeWithProposedOutput: cfg.AgreeWithProposedOutput,
-			completed:               true,
+			status:                  status,
 			// Act function does nothing because the game is already complete
 			act: func(ctx context.Context) error {
 				return nil
@@ -111,32 +110,32 @@ func NewGamePlayer(
 		agreeWithProposedOutput: cfg.AgreeWithProposedOutput,
 		loader:                  loader,
 		logger:                  logger,
-		completed:               status != types.GameStatusInProgress,
+		status:                  status,
 	}, nil
 }
 
-func (g *GamePlayer) ProgressGame(ctx context.Context) bool {
-	if g.completed {
+func (g *GamePlayer) ProgressGame(ctx context.Context) gameTypes.GameStatus {
+	if g.status != gameTypes.GameStatusInProgress {
 		// Game is already complete so don't try to perform further actions.
 		g.logger.Trace("Skipping completed game")
-		return true
+		return g.status
 	}
 	g.logger.Trace("Checking if actions are required")
 	if err := g.act(ctx); err != nil {
 		g.logger.Error("Error when acting on game", "err", err)
 	}
-	if status, err := g.loader.GetGameStatus(ctx); err != nil {
+	status, err := g.loader.GetGameStatus(ctx)
+	if err != nil {
 		g.logger.Warn("Unable to retrieve game status", "err", err)
-	} else {
-		g.logGameStatus(ctx, status)
-		g.completed = status != types.GameStatusInProgress
-		return g.completed
+		return gameTypes.GameStatusInProgress
 	}
-	return false
+	g.logGameStatus(ctx, status)
+	g.status = status
+	return status
 }
 
-func (g *GamePlayer) logGameStatus(ctx context.Context, status types.GameStatus) {
-	if status == types.GameStatusInProgress {
+func (g *GamePlayer) logGameStatus(ctx context.Context, status gameTypes.GameStatus) {
+	if status == gameTypes.GameStatusInProgress {
 		claimCount, err := g.loader.GetClaimCount(ctx)
 		if err != nil {
 			g.logger.Error("Failed to get claim count for in progress game", "err", err)
@@ -145,11 +144,11 @@ func (g *GamePlayer) logGameStatus(ctx context.Context, status types.GameStatus)
 		g.logger.Info("Game info", "claims", claimCount, "status", status)
 		return
 	}
-	var expectedStatus types.GameStatus
+	var expectedStatus gameTypes.GameStatus
 	if g.agreeWithProposedOutput {
-		expectedStatus = types.GameStatusChallengerWon
+		expectedStatus = gameTypes.GameStatusChallengerWon
 	} else {
-		expectedStatus = types.GameStatusDefenderWon
+		expectedStatus = gameTypes.GameStatusDefenderWon
 	}
 	if expectedStatus == status {
 		g.logger.Info("Game won", "status", status)
@@ -159,22 +158,21 @@ func (g *GamePlayer) logGameStatus(ctx context.Context, status types.GameStatus)
 }
 
 type PrestateLoader interface {
-	FetchAbsolutePrestateHash(ctx context.Context) ([]byte, error)
+	FetchAbsolutePrestateHash(ctx context.Context) (common.Hash, error)
 }
 
 // ValidateAbsolutePrestate validates the absolute prestate of the fault game.
 func ValidateAbsolutePrestate(ctx context.Context, trace types.TraceProvider, loader PrestateLoader) error {
-	providerPrestate, err := trace.AbsolutePreState(ctx)
+	providerPrestateHash, err := trace.AbsolutePreStateCommitment(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to get the trace provider's absolute prestate: %w", err)
 	}
-	providerPrestateHash := crypto.Keccak256(providerPrestate)
 	onchainPrestate, err := loader.FetchAbsolutePrestateHash(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to get the onchain absolute prestate: %w", err)
 	}
-	if !bytes.Equal(providerPrestateHash, onchainPrestate) {
-		return fmt.Errorf("trace provider's absolute prestate does not match onchain absolute prestate")
+	if !bytes.Equal(providerPrestateHash[:], onchainPrestate[:]) {
+		return fmt.Errorf("trace provider's absolute prestate does not match onchain absolute prestate: Provider: %s | Chain %s", providerPrestateHash.Hex(), onchainPrestate.Hex())
 	}
 	return nil
 }

op-challenger/game/fault/player_test.go

@@ -6,7 +6,9 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -22,8 +24,8 @@ var (
 func TestProgressGame_LogErrorFromAct(t *testing.T) {
 	handler, game, actor := setupProgressGameTest(t, true)
 	actor.actErr = errors.New("boom")
-	done := game.ProgressGame(context.Background())
-	require.False(t, done, "should not be done")
+	status := game.ProgressGame(context.Background())
+	require.Equal(t, gameTypes.GameStatusInProgress, status)
 	require.Equal(t, 1, actor.callCount, "should perform next actions")
 	errLog := handler.FindLog(log.LvlError, "Error when acting on game")
 	require.NotNil(t, errLog, "should log error")
@@ -38,42 +40,42 @@ func TestProgressGame_LogErrorFromAct(t *testing.T) {
 func TestProgressGame_LogGameStatus(t *testing.T) {
 	tests := []struct {
 		name            string
-		status          types.GameStatus
+		status          gameTypes.GameStatus
 		agreeWithOutput bool
 		logLevel        log.Lvl
 		logMsg          string
 	}{
 		{
 			name:            "GameLostAsDefender",
-			status:          types.GameStatusChallengerWon,
+			status:          gameTypes.GameStatusChallengerWon,
 			agreeWithOutput: false,
 			logLevel:        log.LvlError,
 			logMsg:          "Game lost",
 		},
 		{
 			name:            "GameLostAsChallenger",
-			status:          types.GameStatusDefenderWon,
+			status:          gameTypes.GameStatusDefenderWon,
 			agreeWithOutput: true,
 			logLevel:        log.LvlError,
 			logMsg:          "Game lost",
 		},
 		{
 			name:            "GameWonAsDefender",
-			status:          types.GameStatusDefenderWon,
+			status:          gameTypes.GameStatusDefenderWon,
 			agreeWithOutput: false,
 			logLevel:        log.LvlInfo,
 			logMsg:          "Game won",
 		},
 		{
 			name:            "GameWonAsChallenger",
-			status:          types.GameStatusChallengerWon,
+			status:          gameTypes.GameStatusChallengerWon,
 			agreeWithOutput: true,
 			logLevel:        log.LvlInfo,
 			logMsg:          "Game won",
 		},
 		{
 			name:            "GameInProgress",
-			status:          types.GameStatusInProgress,
+			status:          gameTypes.GameStatusInProgress,
 			agreeWithOutput: true,
 			logLevel:        log.LvlInfo,
 			logMsg:          "Game info",
@@ -85,9 +87,9 @@ func TestProgressGame_LogGameStatus(t *testing.T) {
 			handler, game, gameState := setupProgressGameTest(t, test.agreeWithOutput)
 			gameState.status = test.status
 
-			done := game.ProgressGame(context.Background())
+			status := game.ProgressGame(context.Background())
 			require.Equal(t, 1, gameState.callCount, "should perform next actions")
-			require.Equal(t, test.status != types.GameStatusInProgress, done, "should be done when not in progress")
+			require.Equal(t, test.status, status)
 			errLog := handler.FindLog(test.logLevel, test.logMsg)
 			require.NotNil(t, errLog, "should log game result")
 			require.Equal(t, test.status, errLog.GetContextValue("status"))
@@ -96,19 +98,19 @@ func TestProgressGame_LogGameStatus(t *testing.T) {
 }
 
 func TestDoNotActOnCompleteGame(t *testing.T) {
-	for _, status := range []types.GameStatus{types.GameStatusChallengerWon, types.GameStatusDefenderWon} {
+	for _, status := range []gameTypes.GameStatus{gameTypes.GameStatusChallengerWon, gameTypes.GameStatusDefenderWon} {
 		t.Run(status.String(), func(t *testing.T) {
 			_, game, gameState := setupProgressGameTest(t, true)
 			gameState.status = status
 
-			done := game.ProgressGame(context.Background())
+			fetched := game.ProgressGame(context.Background())
 			require.Equal(t, 1, gameState.callCount, "acts the first time")
-			require.True(t, done, "should be done")
+			require.Equal(t, status, fetched)
 
 			// Should not act when it knows the game is already complete
-			done = game.ProgressGame(context.Background())
+			fetched = game.ProgressGame(context.Background())
 			require.Equal(t, 1, gameState.callCount, "does not act after game is complete")
-			require.True(t, done, "should still be done")
+			require.Equal(t, status, fetched)
 		})
 	}
 }
@@ -119,8 +121,9 @@ func TestValidateAbsolutePrestate(t *testing.T) {
 	t.Run("ValidPrestates", func(t *testing.T) {
 		prestate := []byte{0x00, 0x01, 0x02, 0x03}
 		prestateHash := crypto.Keccak256(prestate)
+		prestateHash[0] = mipsevm.VMStatusUnfinished
 		mockTraceProvider := newMockTraceProvider(false, prestate)
-		mockLoader := newMockPrestateLoader(false, prestateHash)
+		mockLoader := newMockPrestateLoader(false, common.BytesToHash(prestateHash))
 		err := ValidateAbsolutePrestate(context.Background(), mockTraceProvider, mockLoader)
 		require.NoError(t, err)
 	})
@@ -128,7 +131,7 @@ func TestValidateAbsolutePrestate(t *testing.T) {
 	t.Run("TraceProviderErrors", func(t *testing.T) {
 		prestate := []byte{0x00, 0x01, 0x02, 0x03}
 		mockTraceProvider := newMockTraceProvider(true, prestate)
-		mockLoader := newMockPrestateLoader(false, prestate)
+		mockLoader := newMockPrestateLoader(false, common.BytesToHash(prestate))
 		err := ValidateAbsolutePrestate(context.Background(), mockTraceProvider, mockLoader)
 		require.ErrorIs(t, err, mockTraceProviderError)
 	})
@@ -136,14 +139,14 @@ func TestValidateAbsolutePrestate(t *testing.T) {
 	t.Run("LoaderErrors", func(t *testing.T) {
 		prestate := []byte{0x00, 0x01, 0x02, 0x03}
 		mockTraceProvider := newMockTraceProvider(false, prestate)
-		mockLoader := newMockPrestateLoader(true, prestate)
+		mockLoader := newMockPrestateLoader(true, common.BytesToHash(prestate))
 		err := ValidateAbsolutePrestate(context.Background(), mockTraceProvider, mockLoader)
 		require.ErrorIs(t, err, mockLoaderError)
 	})
 
 	t.Run("PrestateMismatch", func(t *testing.T) {
 		mockTraceProvider := newMockTraceProvider(false, []byte{0x00, 0x01, 0x02, 0x03})
-		mockLoader := newMockPrestateLoader(false, []byte{0x00})
+		mockLoader := newMockPrestateLoader(false, common.BytesToHash([]byte{0x00}))
 		err := ValidateAbsolutePrestate(context.Background(), mockTraceProvider, mockLoader)
 		require.Error(t, err)
 	})
@@ -166,7 +169,7 @@ func setupProgressGameTest(t *testing.T, agreeWithProposedRoot bool) (*testlog.C
 }
 
 type stubGameState struct {
-	status     types.GameStatus
+	status     gameTypes.GameStatus
 	claimCount uint64
 	callCount  int
 	actErr     error
@@ -178,7 +181,7 @@ func (s *stubGameState) Act(ctx context.Context) error {
 	return s.actErr
 }
 
-func (s *stubGameState) GetGameStatus(ctx context.Context) (types.GameStatus, error) {
+func (s *stubGameState) GetGameStatus(ctx context.Context) (gameTypes.GameStatus, error) {
 	return s.status, nil
 }
 
@@ -209,21 +212,31 @@ func (m *mockTraceProvider) AbsolutePreState(ctx context.Context) ([]byte, error
 	}
 	return m.prestate, nil
 }
+func (m *mockTraceProvider) AbsolutePreStateCommitment(ctx context.Context) (common.Hash, error) {
+	prestate, err := m.AbsolutePreState(ctx)
+	if err != nil {
+		return common.Hash{}, err
+	}
+
+	hash := common.BytesToHash(crypto.Keccak256(prestate))
+	hash[0] = mipsevm.VMStatusUnfinished
+	return hash, nil
+}
 
 type mockLoader struct {
 	prestateError bool
-	prestate      []byte
+	prestate      common.Hash
 }
 
-func newMockPrestateLoader(prestateError bool, prestate []byte) *mockLoader {
+func newMockPrestateLoader(prestateError bool, prestate common.Hash) *mockLoader {
 	return &mockLoader{
 		prestateError: prestateError,
 		prestate:      prestate,
 	}
 }
-func (m *mockLoader) FetchAbsolutePrestateHash(ctx context.Context) ([]byte, error) {
+func (m *mockLoader) FetchAbsolutePrestateHash(ctx context.Context) (common.Hash, error) {
 	if m.prestateError {
-		return nil, mockLoaderError
+		return common.Hash{}, mockLoaderError
 	}
 	return m.prestate, nil
 }

op-challenger/game/fault/responder/responder.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 
 	"github.com/ethereum/go-ethereum"
@@ -81,23 +82,23 @@ func (r *faultResponder) BuildTx(ctx context.Context, response types.Claim) ([]b
 
 // CallResolve determines if the resolve function on the fault dispute game contract
 // would succeed. Returns the game status if the call would succeed, errors otherwise.
-func (r *faultResponder) CallResolve(ctx context.Context) (types.GameStatus, error) {
+func (r *faultResponder) CallResolve(ctx context.Context) (gameTypes.GameStatus, error) {
 	txData, err := r.buildResolveData()
 	if err != nil {
-		return types.GameStatusInProgress, err
+		return gameTypes.GameStatusInProgress, err
 	}
 	res, err := r.txMgr.Call(ctx, ethereum.CallMsg{
 		To:   &r.fdgAddr,
 		Data: txData,
 	}, nil)
 	if err != nil {
-		return types.GameStatusInProgress, err
+		return gameTypes.GameStatusInProgress, err
 	}
 	var status uint8
 	if err = r.fdgAbi.UnpackIntoInterface(&status, "resolve", res); err != nil {
-		return types.GameStatusInProgress, err
+		return gameTypes.GameStatusInProgress, err
 	}
-	return types.GameStatusFromUint8(status)
+	return gameTypes.GameStatusFromUint8(status)
 }
 
 // Resolve executes a resolve transaction to resolve a fault dispute game.

op-challenger/game/fault/responder/responder_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 
@@ -32,7 +33,7 @@ func TestCallResolve(t *testing.T) {
 		mockTxMgr.callFails = true
 		status, err := responder.CallResolve(context.Background())
 		require.ErrorIs(t, err, mockCallError)
-		require.Equal(t, types.GameStatusInProgress, status)
+		require.Equal(t, gameTypes.GameStatusInProgress, status)
 		require.Equal(t, 0, mockTxMgr.calls)
 	})
 
@@ -41,7 +42,7 @@ func TestCallResolve(t *testing.T) {
 		mockTxMgr.callBytes = []byte{0x00, 0x01}
 		status, err := responder.CallResolve(context.Background())
 		require.Error(t, err)
-		require.Equal(t, types.GameStatusInProgress, status)
+		require.Equal(t, gameTypes.GameStatusInProgress, status)
 		require.Equal(t, 1, mockTxMgr.calls)
 	})
 
@@ -49,7 +50,7 @@ func TestCallResolve(t *testing.T) {
 		responder, mockTxMgr := newTestFaultResponder(t)
 		status, err := responder.CallResolve(context.Background())
 		require.NoError(t, err)
-		require.Equal(t, types.GameStatusInProgress, status)
+		require.Equal(t, gameTypes.GameStatusInProgress, status)
 		require.Equal(t, 1, mockTxMgr.calls)
 	})
 }

op-challenger/game/fault/solver/solver.go

 package solver
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -132,7 +133,7 @@ func (s *Solver) defend(ctx context.Context, claim types.Claim) (*types.Claim, e
 // agreeWithClaim returns true if the claim is correct according to the internal [TraceProvider].
 func (s *Solver) agreeWithClaim(ctx context.Context, claim types.ClaimData) (bool, error) {
 	ourValue, err := s.traceAtPosition(ctx, claim.Position)
-	return ourValue == claim.Value, err
+	return bytes.Equal(ourValue[:], claim.Value[:]), err
 }
 
 // traceAtPosition returns the [common.Hash] from internal [TraceProvider] at the given [Position].

op-challenger/game/fault/trace/alphabet/provider.go

@@ -6,6 +6,7 @@ import (
 	"math/big"
 	"strings"
 
+	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -58,7 +59,7 @@ func (ap *AlphabetTraceProvider) Get(ctx context.Context, i uint64) (common.Hash
 	if err != nil {
 		return common.Hash{}, err
 	}
-	return crypto.Keccak256Hash(claimBytes), nil
+	return alphabetStateHash(claimBytes), nil
 }
 
 // AbsolutePreState returns the absolute pre-state for the alphabet trace.
@@ -66,11 +67,27 @@ func (ap *AlphabetTraceProvider) AbsolutePreState(ctx context.Context) ([]byte,
 	return common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000060"), nil
 }
 
+func (ap *AlphabetTraceProvider) AbsolutePreStateCommitment(ctx context.Context) (common.Hash, error) {
+	prestate, err := ap.AbsolutePreState(ctx)
+	if err != nil {
+		return common.Hash{}, err
+	}
+	hash := common.BytesToHash(crypto.Keccak256(prestate))
+	hash[0] = mipsevm.VMStatusUnfinished
+	return hash, nil
+}
+
 // BuildAlphabetPreimage constructs the claim bytes for the index and state item.
 func BuildAlphabetPreimage(i uint64, letter string) []byte {
 	return append(IndexToBytes(i), LetterToBytes(letter)...)
 }
 
+func alphabetStateHash(state []byte) common.Hash {
+	h := crypto.Keccak256Hash(state)
+	h[0] = mipsevm.VMStatusInvalid
+	return h
+}
+
 // IndexToBytes converts an index to a byte slice big endian
 func IndexToBytes(i uint64) []byte {
 	big := new(big.Int)

op-challenger/game/fault/trace/alphabet/provider_test.go

@@ -6,12 +6,11 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/require"
 )
 
 func alphabetClaim(index uint64, letter string) common.Hash {
-	return crypto.Keccak256Hash(BuildAlphabetPreimage(index, letter))
+	return alphabetStateHash(BuildAlphabetPreimage(index, letter))
 }
 
 // TestAlphabetProvider_Get_ClaimsByTraceIndex tests the [fault.AlphabetProvider] Get function.
@@ -60,7 +59,7 @@ func FuzzIndexToBytes(f *testing.F) {
 // returns the correct pre-image for a index.
 func TestGetStepData_Succeeds(t *testing.T) {
 	ap := NewTraceProvider("abc", 2)
-	expected := BuildAlphabetPreimage(0, "a'")
+	expected := BuildAlphabetPreimage(0, "a")
 	retrieved, proof, data, err := ap.GetStepData(context.Background(), uint64(1))
 	require.NoError(t, err)
 	require.Equal(t, expected, retrieved)

op-challenger/game/fault/trace/cannon/provider.go

@@ -15,9 +15,10 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
 )
 
 const (
@@ -25,7 +26,7 @@ const (
 )
 
 type proofData struct {
-	ClaimValue   hexutil.Bytes `json:"post"`
+	ClaimValue   common.Hash   `json:"post"`
 	StateData    hexutil.Bytes `json:"state-data"`
 	ProofData    hexutil.Bytes `json:"proof-data"`
 	OracleKey    hexutil.Bytes `json:"oracle-key,omitempty"`
@@ -86,7 +87,7 @@ func (p *CannonTraceProvider) Get(ctx context.Context, i uint64) (common.Hash, e
 	if err != nil {
 		return common.Hash{}, err
 	}
-	value := common.BytesToHash(proof.ClaimValue)
+	value := proof.ClaimValue
 
 	if value == (common.Hash{}) {
 		return common.Hash{}, errors.New("proof missing post hash")
@@ -122,6 +123,18 @@ func (p *CannonTraceProvider) AbsolutePreState(ctx context.Context) ([]byte, err
 	return state.EncodeWitness(), nil
 }
 
+func (p *CannonTraceProvider) AbsolutePreStateCommitment(ctx context.Context) (common.Hash, error) {
+	state, err := p.AbsolutePreState(ctx)
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("cannot load absolute pre-state: %w", err)
+	}
+	hash, err := mipsevm.StateWitness(state).StateHash()
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("cannot hash absolute pre-state: %w", err)
+	}
+	return hash, nil
+}
+
 // loadProof will attempt to load or generate the proof data at the specified index
 // If the requested index is beyond the end of the actual trace it is extended with no-op instructions.
 func (p *CannonTraceProvider) loadProof(ctx context.Context, i uint64) (*proofData, error) {
@@ -151,9 +164,13 @@ func (p *CannonTraceProvider) loadProof(ctx context.Context, i uint64) (*proofDa
 				// Extend the trace out to the full length using a no-op instruction that doesn't change any state
 				// No execution is done, so no proof-data or oracle values are required.
 				witness := state.EncodeWitness()
+				witnessHash, err := mipsevm.StateWitness(witness).StateHash()
+				if err != nil {
+					return nil, fmt.Errorf("cannot hash witness: %w", err)
+				}
 				proof := &proofData{
-					ClaimValue:   crypto.Keccak256(witness),
-					StateData:    witness,
+					ClaimValue:   witnessHash,
+					StateData:    hexutil.Bytes(witness),
 					ProofData:    []byte{},
 					OracleKey:    nil,
 					OracleValue:  nil,

op-challenger/game/fault/trace/cannon/provider_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum-optimism/optimism/op-service/ioutil"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
 )
@@ -43,7 +42,9 @@ func TestGet(t *testing.T) {
 		value, err := provider.Get(context.Background(), 7000)
 		require.NoError(t, err)
 		require.Contains(t, generator.generated, 7000, "should have tried to generate the proof")
-		require.Equal(t, crypto.Keccak256Hash(generator.finalState.EncodeWitness()), value)
+		stateHash, err := generator.finalState.EncodeWitness().StateHash()
+		require.NoError(t, err)
+		require.Equal(t, stateHash, value)
 	})
 
 	t.Run("MissingPostHash", func(t *testing.T) {
@@ -86,7 +87,7 @@ func TestGetStepData(t *testing.T) {
 			Exited: true,
 		}
 		generator.proof = &proofData{
-			ClaimValue:   common.Hash{0xaa}.Bytes(),
+			ClaimValue:   common.Hash{0xaa},
 			StateData:    []byte{0xbb},
 			ProofData:    []byte{0xcc},
 			OracleKey:    common.Hash{0xdd}.Bytes(),
@@ -111,7 +112,7 @@ func TestGetStepData(t *testing.T) {
 			Exited: true,
 		}
 		generator.proof = &proofData{
-			ClaimValue:   common.Hash{0xaa}.Bytes(),
+			ClaimValue:   common.Hash{0xaa},
 			StateData:    []byte{0xbb},
 			ProofData:    []byte{0xcc},
 			OracleKey:    common.Hash{0xdd}.Bytes(),
@@ -185,7 +186,7 @@ func TestAbsolutePreState(t *testing.T) {
 			Step:           0,
 			Registers:      [32]uint32{},
 		}
-		require.Equal(t, state.EncodeWitness(), preState)
+		require.Equal(t, []byte(state.EncodeWitness()), preState)
 	})
 }
 

op-challenger/game/fault/types/types.go

@@ -3,7 +3,6 @@ package types
 import (
 	"context"
 	"errors"
-	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -13,36 +12,6 @@ var (
 	ErrGameDepthReached = errors.New("game depth reached")
 )
 
-type GameStatus uint8
-
-const (
-	GameStatusInProgress GameStatus = iota
-	GameStatusChallengerWon
-	GameStatusDefenderWon
-)
-
-// String returns the string representation of the game status.
-func (s GameStatus) String() string {
-	switch s {
-	case GameStatusInProgress:
-		return "In Progress"
-	case GameStatusChallengerWon:
-		return "Challenger Won"
-	case GameStatusDefenderWon:
-		return "Defender Won"
-	default:
-		return "Unknown"
-	}
-}
-
-// GameStatusFromUint8 returns a game status from the uint8 representation.
-func GameStatusFromUint8(i uint8) (GameStatus, error) {
-	if i > 2 {
-		return GameStatus(i), fmt.Errorf("invalid game status: %d", i)
-	}
-	return GameStatus(i), nil
-}
-
 // PreimageOracleData encapsulates the preimage oracle data
 // to load into the onchain oracle.
 type PreimageOracleData struct {
@@ -105,6 +74,9 @@ type TraceProvider interface {
 
 	// AbsolutePreState is the pre-image value of the trace that transitions to the trace value at index 0
 	AbsolutePreState(ctx context.Context) (preimage []byte, err error)
+
+	// AbsolutePreStateCommitment is the commitment of the pre-image value of the trace that transitions to the trace value at index 0
+	AbsolutePreStateCommitment(ctx context.Context) (hash common.Hash, err error)
 }
 
 // ClaimData is the core of a claim. It must be unique inside a specific game.

op-challenger/game/fault/types/types_test.go

 package types
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
-var validGameStatuses = []GameStatus{
-	GameStatusInProgress,
-	GameStatusChallengerWon,
-	GameStatusDefenderWon,
-}
-
-func TestGameStatusFromUint8(t *testing.T) {
-	for _, status := range validGameStatuses {
-		t.Run(fmt.Sprintf("Valid Game Status %v", status), func(t *testing.T) {
-			parsed, err := GameStatusFromUint8(uint8(status))
-			require.NoError(t, err)
-			require.Equal(t, status, parsed)
-		})
-	}
-
-	t.Run("Invalid", func(t *testing.T) {
-		status, err := GameStatusFromUint8(3)
-		require.Error(t, err)
-		require.Equal(t, GameStatus(3), status)
-	})
-}
-
 func TestNewPreimageOracleData(t *testing.T) {
 	t.Run("LocalData", func(t *testing.T) {
 		data := NewPreimageOracleData([]byte{1, 2, 3}, []byte{4, 5, 6}, 7)

op-challenger/game/monitor.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler"
-	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/clock"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -27,7 +26,6 @@ type gameScheduler interface {
 
 type gameMonitor struct {
 	logger           log.Logger
-	metrics          metrics.Metricer
 	clock            clock.Clock
 	source           gameSource
 	scheduler        gameScheduler
@@ -38,7 +36,6 @@ type gameMonitor struct {
 
 func newGameMonitor(
 	logger log.Logger,
-	m metrics.Metricer,
 	cl clock.Clock,
 	source gameSource,
 	scheduler gameScheduler,
@@ -48,7 +45,6 @@ func newGameMonitor(
 ) *gameMonitor {
 	return &gameMonitor{
 		logger:           logger,
-		metrics:          m,
 		clock:            cl,
 		scheduler:        scheduler,
 		source:           source,

op-challenger/game/monitor_test.go

@@ -6,7 +6,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum-optimism/optimism/op-service/clock"
 	"github.com/ethereum/go-ethereum/common"
@@ -101,7 +100,7 @@ func setupMonitorTest(t *testing.T, allowedGames []common.Address) (*gameMonitor
 		return i, nil
 	}
 	sched := &stubScheduler{}
-	monitor := newGameMonitor(logger, metrics.NoopMetrics, clock.SystemClock, source, sched, time.Duration(0), fetchBlockNum, allowedGames)
+	monitor := newGameMonitor(logger, clock.SystemClock, source, sched, time.Duration(0), fetchBlockNum, allowedGames)
 	return monitor, source, sched
 }
 

op-challenger/game/scheduler/coordinator.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"golang.org/x/exp/slices"
@@ -17,7 +19,7 @@ type PlayerCreator func(address common.Address, dir string) (GamePlayer, error)
 type gameState struct {
 	player   GamePlayer
 	inflight bool
-	resolved bool
+	status   types.GameStatus
 }
 
 // coordinator manages the set of current games, queues games to be played (on separate worker threads) and
@@ -31,6 +33,7 @@ type coordinator struct {
 	resultQueue <-chan job
 
 	logger       log.Logger
+	m            SchedulerMetricer
 	createPlayer PlayerCreator
 	states       map[common.Address]*gameState
 	disk         DiskManager
@@ -49,18 +52,36 @@ func (c *coordinator) schedule(ctx context.Context, games []common.Address) erro
 		}
 	}
 
+	var gamesInProgress int
+	var gamesChallengerWon int
+	var gamesDefenderWon int
 	var errs []error
+	var jobs []job
 	// Next collect all the jobs to schedule and ensure all games are recorded in the states map.
 	// Otherwise, results may start being processed before all games are recorded, resulting in existing
 	// data directories potentially being deleted for games that are required.
-	var jobs []job
 	for _, addr := range games {
 		if j, err := c.createJob(addr); err != nil {
 			errs = append(errs, err)
 		} else if j != nil {
 			jobs = append(jobs, *j)
+			c.m.RecordGameUpdateScheduled()
+		}
+		state, ok := c.states[addr]
+		if ok {
+			switch state.status {
+			case types.GameStatusInProgress:
+				gamesInProgress++
+			case types.GameStatusDefenderWon:
+				gamesDefenderWon++
+			case types.GameStatusChallengerWon:
+				gamesChallengerWon++
+			}
+		} else {
+			c.logger.Warn("Game not found in states map", "game", addr)
 		}
 	}
+	c.m.RecordGamesStatus(gamesInProgress, gamesChallengerWon, gamesDefenderWon)
 
 	// Finally, enqueue the jobs
 	for _, j := range jobs {
@@ -114,15 +135,16 @@ func (c *coordinator) processResult(j job) error {
 		return fmt.Errorf("game %v received unexpected result: %w", j.addr, errUnknownGame)
 	}
 	state.inflight = false
-	state.resolved = j.resolved
+	state.status = j.status
 	c.deleteResolvedGameFiles()
+	c.m.RecordGameUpdateCompleted()
 	return nil
 }
 
 func (c *coordinator) deleteResolvedGameFiles() {
 	var keepGames []common.Address
 	for addr, state := range c.states {
-		if !state.resolved || state.inflight {
+		if state.status == types.GameStatusInProgress || state.inflight {
 			keepGames = append(keepGames, addr)
 		}
 	}
@@ -131,9 +153,10 @@ func (c *coordinator) deleteResolvedGameFiles() {
 	}
 }
 
-func newCoordinator(logger log.Logger, jobQueue chan<- job, resultQueue <-chan job, createPlayer PlayerCreator, disk DiskManager) *coordinator {
+func newCoordinator(logger log.Logger, m SchedulerMetricer, jobQueue chan<- job, resultQueue <-chan job, createPlayer PlayerCreator, disk DiskManager) *coordinator {
 	return &coordinator{
 		logger:       logger,
+		m:            m,
 		jobQueue:     jobQueue,
 		resultQueue:  resultQueue,
 		createPlayer: createPlayer,

op-challenger/game/scheduler/coordinator_test.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
+	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -140,7 +142,7 @@ func TestDeleteDataForResolvedGames(t *testing.T) {
 	require.NoError(t, c.schedule(ctx, []common.Address{gameAddr3}))
 	require.Len(t, workQueue, 1)
 	j := <-workQueue
-	j.resolved = true
+	j.status = types.GameStatusDefenderWon
 	require.NoError(t, c.processResult(j))
 	// But ensure its data directory is marked as existing
 	disk.DirForGame(gameAddr3)
@@ -155,7 +157,9 @@ func TestDeleteDataForResolvedGames(t *testing.T) {
 	// Game 3 hasn't yet progressed (update is still in flight)
 	for i := 0; i < len(gameAddrs)-1; i++ {
 		j := <-workQueue
-		j.resolved = j.addr == gameAddr2
+		if j.addr == gameAddr2 {
+			j.status = types.GameStatusDefenderWon
+		}
 		require.NoError(t, c.processResult(j))
 	}
 
@@ -229,20 +233,20 @@ func setupCoordinatorTest(t *testing.T, bufferSize int) (*coordinator, <-chan jo
 		created: make(map[common.Address]*stubGame),
 	}
 	disk := &stubDiskManager{gameDirExists: make(map[common.Address]bool)}
-	c := newCoordinator(logger, workQueue, resultQueue, games.CreateGame, disk)
+	c := newCoordinator(logger, metrics.NoopMetrics, workQueue, resultQueue, games.CreateGame, disk)
 	return c, workQueue, resultQueue, games, disk
 }
 
 type stubGame struct {
 	addr          common.Address
 	progressCount int
-	done          bool
+	status        types.GameStatus
 	dir           string
 }
 
-func (g *stubGame) ProgressGame(_ context.Context) bool {
+func (g *stubGame) ProgressGame(_ context.Context) types.GameStatus {
 	g.progressCount++
-	return g.done
+	return g.status
 }
 
 type createdGames struct {
@@ -259,10 +263,14 @@ func (c *createdGames) CreateGame(addr common.Address, dir string) (GamePlayer,
 	if _, exists := c.created[addr]; exists {
 		c.t.Fatalf("game %v already exists", addr)
 	}
+	status := types.GameStatusInProgress
+	if addr == c.createCompleted {
+		status = types.GameStatusDefenderWon
+	}
 	game := &stubGame{
-		addr: addr,
-		done: addr == c.createCompleted,
-		dir:  dir,
+		addr:   addr,
+		status: status,
+		dir:    dir,
 	}
 	c.created[addr] = game
 	return game, nil

op-challenger/game/scheduler/scheduler.go

@@ -11,6 +11,12 @@ import (
 
 var ErrBusy = errors.New("busy scheduling previous update")
 
+type SchedulerMetricer interface {
+	RecordGamesStatus(inProgress, defenderWon, challengerWon int)
+	RecordGameUpdateScheduled()
+	RecordGameUpdateCompleted()
+}
+
 type Scheduler struct {
 	logger         log.Logger
 	coordinator    *coordinator
@@ -22,7 +28,7 @@ type Scheduler struct {
 	cancel         func()
 }
 
-func NewScheduler(logger log.Logger, disk DiskManager, maxConcurrency uint, createPlayer PlayerCreator) *Scheduler {
+func NewScheduler(logger log.Logger, m SchedulerMetricer, disk DiskManager, maxConcurrency uint, createPlayer PlayerCreator) *Scheduler {
 	// Size job and results queues to be fairly small so backpressure is applied early
 	// but with enough capacity to keep the workers busy
 	jobQueue := make(chan job, maxConcurrency*2)
@@ -34,7 +40,7 @@ func NewScheduler(logger log.Logger, disk DiskManager, maxConcurrency uint, crea
 
 	return &Scheduler{
 		logger:         logger,
-		coordinator:    newCoordinator(logger, jobQueue, resultQueue, createPlayer, disk),
+		coordinator:    newCoordinator(logger, m, jobQueue, resultQueue, createPlayer, disk),
 		maxConcurrency: maxConcurrency,
 		scheduleQueue:  scheduleQueue,
 		jobQueue:       jobQueue,

op-challenger/game/scheduler/scheduler_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -18,7 +19,7 @@ func TestSchedulerProcessesGames(t *testing.T) {
 	}
 	removeExceptCalls := make(chan []common.Address)
 	disk := &trackingDiskManager{removeExceptCalls: removeExceptCalls}
-	s := NewScheduler(logger, disk, 2, createPlayer)
+	s := NewScheduler(logger, metrics.NoopMetrics, disk, 2, createPlayer)
 	s.Start(ctx)
 
 	gameAddr1 := common.Address{0xaa}
@@ -46,7 +47,7 @@ func TestReturnBusyWhenScheduleQueueFull(t *testing.T) {
 	}
 	removeExceptCalls := make(chan []common.Address)
 	disk := &trackingDiskManager{removeExceptCalls: removeExceptCalls}
-	s := NewScheduler(logger, disk, 2, createPlayer)
+	s := NewScheduler(logger, metrics.NoopMetrics, disk, 2, createPlayer)
 
 	// Scheduler not started - first call fills the queue
 	require.NoError(t, s.Schedule([]common.Address{{0xaa}}))

op-challenger/game/scheduler/types.go

@@ -4,10 +4,12 @@ import (
 	"context"
 
 	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
 )
 
 type GamePlayer interface {
-	ProgressGame(ctx context.Context) bool
+	ProgressGame(ctx context.Context) types.GameStatus
 }
 
 type DiskManager interface {
@@ -16,7 +18,7 @@ type DiskManager interface {
 }
 
 type job struct {
-	addr     common.Address
-	player   GamePlayer
-	resolved bool
+	addr   common.Address
+	player GamePlayer
+	status types.GameStatus
 }

op-challenger/game/scheduler/worker.go

@@ -15,7 +15,7 @@ func progressGames(ctx context.Context, in <-chan job, out chan<- job, wg *sync.
 		case <-ctx.Done():
 			return
 		case j := <-in:
-			j.resolved = j.player.ProgressGame(ctx)
+			j.status = j.player.ProgressGame(ctx)
 			out <- j
 		}
 	}

op-challenger/game/scheduler/worker_test.go

@@ -6,6 +6,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
+
 	"github.com/stretchr/testify/require"
 )
 
@@ -20,17 +22,17 @@ func TestWorkerShouldProcessJobsUntilContextDone(t *testing.T) {
 	go progressGames(ctx, in, out, &wg)
 
 	in <- job{
-		player: &stubPlayer{done: false},
+		player: &stubPlayer{status: types.GameStatusInProgress},
 	}
 	in <- job{
-		player: &stubPlayer{done: true},
+		player: &stubPlayer{status: types.GameStatusDefenderWon},
 	}
 
 	result1 := readWithTimeout(t, out)
 	result2 := readWithTimeout(t, out)
 
-	require.Equal(t, result1.resolved, false)
-	require.Equal(t, result2.resolved, true)
+	require.Equal(t, result1.status, types.GameStatusInProgress)
+	require.Equal(t, result2.status, types.GameStatusDefenderWon)
 
 	// Cancel the context which should exit the worker
 	cancel()
@@ -38,11 +40,11 @@ func TestWorkerShouldProcessJobsUntilContextDone(t *testing.T) {
 }
 
 type stubPlayer struct {
-	done bool
+	status types.GameStatus
 }
 
-func (s *stubPlayer) ProgressGame(ctx context.Context) bool {
-	return s.done
+func (s *stubPlayer) ProgressGame(ctx context.Context) types.GameStatus {
+	return s.status
 }
 
 func readWithTimeout[T any](t *testing.T, ch <-chan T) T {

op-challenger/game/service.go

@@ -69,13 +69,14 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*Se
 	disk := newDiskManager(cfg.Datadir)
 	sched := scheduler.NewScheduler(
 		logger,
+		m,
 		disk,
 		cfg.MaxConcurrency,
 		func(addr common.Address, dir string) (scheduler.GamePlayer, error) {
 			return fault.NewGamePlayer(ctx, logger, m, cfg, dir, addr, txMgr, client)
 		})
 
-	monitor := newGameMonitor(logger, m, cl, loader, sched, cfg.GameWindow, client.BlockNumber, cfg.GameAllowlist)
+	monitor := newGameMonitor(logger, cl, loader, sched, cfg.GameWindow, client.BlockNumber, cfg.GameAllowlist)
 
 	m.RecordInfo(version.SimpleWithMeta)
 	m.RecordUp()

op-challenger/game/types/types.go

+package types
+
+import (
+	"fmt"
+)
+
+type GameStatus uint8
+
+const (
+	GameStatusInProgress GameStatus = iota
+	GameStatusChallengerWon
+	GameStatusDefenderWon
+)
+
+// String returns the string representation of the game status.
+func (s GameStatus) String() string {
+	switch s {
+	case GameStatusInProgress:
+		return "In Progress"
+	case GameStatusChallengerWon:
+		return "Challenger Won"
+	case GameStatusDefenderWon:
+		return "Defender Won"
+	default:
+		return "Unknown"
+	}
+}
+
+// GameStatusFromUint8 returns a game status from the uint8 representation.
+func GameStatusFromUint8(i uint8) (GameStatus, error) {
+	if i > 2 {
+		return GameStatus(i), fmt.Errorf("invalid game status: %d", i)
+	}
+	return GameStatus(i), nil
+}

op-challenger/game/types/types_test.go

+package types
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+var validGameStatuses = []GameStatus{
+	GameStatusInProgress,
+	GameStatusChallengerWon,
+	GameStatusDefenderWon,
+}
+
+func TestGameStatusFromUint8(t *testing.T) {
+	for _, status := range validGameStatuses {
+		t.Run(fmt.Sprintf("Valid Game Status %v", status), func(t *testing.T) {
+			parsed, err := GameStatusFromUint8(uint8(status))
+			require.NoError(t, err)
+			require.Equal(t, status, parsed)
+		})
+	}
+
+	t.Run("Invalid", func(t *testing.T) {
+		status, err := GameStatusFromUint8(3)
+		require.Error(t, err)
+		require.Equal(t, GameStatus(3), status)
+	})
+}

op-challenger/metrics/metrics.go

@@ -24,6 +24,11 @@ type Metricer interface {
 	RecordGameStep()
 	RecordGameMove()
 	RecordCannonExecutionTime(t float64)
+
+	RecordGamesStatus(inProgress, defenderWon, challengerWon int)
+
+	RecordGameUpdateScheduled()
+	RecordGameUpdateCompleted()
 }
 
 type Metrics struct {
@@ -36,9 +41,13 @@ type Metrics struct {
 	info prometheus.GaugeVec
 	up   prometheus.Gauge
 
-	moves               prometheus.Counter
-	steps               prometheus.Counter
+	moves prometheus.Counter
+	steps prometheus.Counter
+
 	cannonExecutionTime prometheus.Histogram
+
+	trackedGames  prometheus.GaugeVec
+	inflightGames prometheus.Gauge
 }
 
 var _ Metricer = (*Metrics)(nil)
@@ -80,7 +89,21 @@ func NewMetrics() *Metrics {
 			Namespace: Namespace,
 			Name:      "cannon_execution_time",
 			Help:      "Time (in seconds) to execute cannon",
-			Buckets:   append([]float64{1.0, 10.0}, prometheus.ExponentialBuckets(30.0, 2.0, 14)...),
+			Buckets: append(
+				[]float64{1.0, 10.0},
+				prometheus.ExponentialBuckets(30.0, 2.0, 14)...),
+		}),
+		trackedGames: *factory.NewGaugeVec(prometheus.GaugeOpts{
+			Namespace: Namespace,
+			Name:      "tracked_games",
+			Help:      "Number of games being tracked by the challenger",
+		}, []string{
+			"status",
+		}),
+		inflightGames: factory.NewGauge(prometheus.GaugeOpts{
+			Namespace: Namespace,
+			Name:      "inflight_games",
+			Help:      "Number of games being tracked by the challenger",
 		}),
 	}
 }
@@ -89,7 +112,12 @@ func (m *Metrics) Serve(ctx context.Context, host string, port int) error {
 	return opmetrics.ListenAndServe(ctx, m.registry, host, port)
 }
 
-func (m *Metrics) StartBalanceMetrics(ctx context.Context, l log.Logger, client *ethclient.Client, account common.Address) {
+func (m *Metrics) StartBalanceMetrics(
+	ctx context.Context,
+	l log.Logger,
+	client *ethclient.Client,
+	account common.Address,
+) {
 	opmetrics.LaunchBalanceMetrics(ctx, l, m.registry, m.ns, client, account)
 }
 
@@ -120,3 +148,17 @@ func (m *Metrics) RecordGameStep() {
 func (m *Metrics) RecordCannonExecutionTime(t float64) {
 	m.cannonExecutionTime.Observe(t)
 }
+
+func (m *Metrics) RecordGamesStatus(inProgress, defenderWon, challengerWon int) {
+	m.trackedGames.WithLabelValues("in_progress").Set(float64(inProgress))
+	m.trackedGames.WithLabelValues("defender_won").Set(float64(defenderWon))
+	m.trackedGames.WithLabelValues("challenger_won").Set(float64(challengerWon))
+}
+
+func (m *Metrics) RecordGameUpdateScheduled() {
+	m.inflightGames.Add(1)
+}
+
+func (m *Metrics) RecordGameUpdateCompleted() {
+	m.inflightGames.Sub(1)
+}

op-challenger/metrics/noop.go

@@ -10,8 +10,15 @@ type noopMetrics struct {
 
 var NoopMetrics Metricer = new(noopMetrics)
 
-func (*noopMetrics) RecordInfo(version string)           {}
-func (*noopMetrics) RecordUp()                           {}
-func (*noopMetrics) RecordGameMove()                     {}
-func (*noopMetrics) RecordGameStep()                     {}
+func (*noopMetrics) RecordInfo(version string) {}
+func (*noopMetrics) RecordUp()                 {}
+
+func (*noopMetrics) RecordGameMove() {}
+func (*noopMetrics) RecordGameStep() {}
+
 func (*noopMetrics) RecordCannonExecutionTime(t float64) {}
+
+func (*noopMetrics) RecordGamesStatus(inProgress, defenderWon, challengerWon int) {}
+
+func (*noopMetrics) RecordGameUpdateScheduled() {}
+func (*noopMetrics) RecordGameUpdateCompleted() {}

op-e2e/bridge_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/geth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -40,14 +41,14 @@ func TestERC20BridgeDeposits(t *testing.T) {
 	// Deploy WETH9
 	weth9Address, tx, WETH9, err := bindings.DeployWETH9(opts, l1Client)
 	require.NoError(t, err)
-	_, err = waitForTransaction(tx.Hash(), l1Client, 3*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
+	_, err = geth.WaitForTransaction(tx.Hash(), l1Client, 3*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
 	require.NoError(t, err, "Waiting for deposit tx on L1")
 
 	// Get some WETH
 	opts.Value = big.NewInt(params.Ether)
 	tx, err = WETH9.Fallback(opts, []byte{})
 	require.NoError(t, err)
-	_, err = waitForTransaction(tx.Hash(), l1Client, 3*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
+	_, err = geth.WaitForTransaction(tx.Hash(), l1Client, 3*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
 	require.NoError(t, err)
 	opts.Value = nil
 	wethBalance, err := WETH9.BalanceOf(&bind.CallOpts{}, opts.From)
@@ -61,7 +62,7 @@ func TestERC20BridgeDeposits(t *testing.T) {
 	require.NoError(t, err)
 	tx, err = optimismMintableTokenFactory.CreateOptimismMintableERC20(l2Opts, weth9Address, "L2-WETH", "L2-WETH")
 	require.NoError(t, err)
-	_, err = waitForTransaction(tx.Hash(), l2Client, 3*time.Duration(cfg.DeployConfig.L2BlockTime)*time.Second)
+	_, err = geth.WaitForTransaction(tx.Hash(), l2Client, 3*time.Duration(cfg.DeployConfig.L2BlockTime)*time.Second)
 	require.NoError(t, err)
 
 	// Get the deployment event to have access to the L2 WETH9 address
@@ -76,7 +77,7 @@ func TestERC20BridgeDeposits(t *testing.T) {
 	// Approve WETH9 with the bridge
 	tx, err = WETH9.Approve(opts, cfg.L1Deployments.L1StandardBridgeProxy, new(big.Int).SetUint64(math.MaxUint64))
 	require.NoError(t, err)
-	_, err = waitForTransaction(tx.Hash(), l1Client, 6*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
+	_, err = geth.WaitForTransaction(tx.Hash(), l1Client, 6*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
 	require.NoError(t, err)
 
 	// Bridge the WETH9
@@ -84,7 +85,7 @@ func TestERC20BridgeDeposits(t *testing.T) {
 	require.NoError(t, err)
 	tx, err = l1StandardBridge.BridgeERC20(opts, weth9Address, event.LocalToken, big.NewInt(100), 100000, []byte{})
 	require.NoError(t, err)
-	depositReceipt, err := waitForTransaction(tx.Hash(), l1Client, 3*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
+	depositReceipt, err := geth.WaitForTransaction(tx.Hash(), l1Client, 3*time.Duration(cfg.DeployConfig.L1BlockTime)*time.Second)
 	require.NoError(t, err)
 
 	t.Log("Deposit through L1StandardBridge", "gas used", depositReceipt.GasUsed)
@@ -103,7 +104,7 @@ func TestERC20BridgeDeposits(t *testing.T) {
 
 	depositTx, err := derive.UnmarshalDepositLogEvent(&depositEvent.Raw)
 	require.NoError(t, err)
-	_, err = waitForTransaction(types.NewTx(depositTx).Hash(), l2Client, 3*time.Duration(cfg.DeployConfig.L2BlockTime)*time.Second)
+	_, err = geth.WaitForTransaction(types.NewTx(depositTx).Hash(), l2Client, 3*time.Duration(cfg.DeployConfig.L2BlockTime)*time.Second)
 	require.NoError(t, err)
 
 	// Ensure that the deposit went through

op-e2e/e2eutils/disputegame/honest_helper.go

@@ -42,3 +42,18 @@ func (h *HonestHelper) Defend(ctx context.Context, claimIdx int64) {
 	h.game.require.NoErrorf(err, "Get correct claim at trace index %v", traceIdx)
 	h.game.Defend(ctx, claimIdx, value)
 }
+
+func (h *HonestHelper) StepFails(ctx context.Context, claimIdx int64, isAttack bool) {
+	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
+	defer cancel()
+	claim := h.game.getClaim(ctx, claimIdx)
+	pos := types.NewPositionFromGIndex(claim.Position.Uint64())
+	traceIdx := pos.TraceIndex(int(h.game.MaxDepth(ctx)))
+	if !isAttack {
+		// If we're defending, then the step will be from the trace to the next one
+		traceIdx += 1
+	}
+	prestate, proofData, _, err := h.correctTrace.GetStepData(ctx, traceIdx)
+	h.require.NoError(err, "Get step data")
+	h.game.StepFails(claimIdx, isAttack, prestate, proofData)
+}

op-e2e/fakepos.go → op-e2e/e2eutils/geth/fakepos.go

-package op_e2e
+package geth
 
 import (
 	"time"

op-e2e/e2eutils/geth/peers.go

+package geth
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/eth/ethconfig"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/stretchr/testify/require"
+)
+
+// ConnectP2P creates a p2p peer connection between node1 and node2.
+func ConnectP2P(t *testing.T, node1 *ethclient.Client, node2 *ethclient.Client) {
+	var targetInfo p2p.NodeInfo
+	require.NoError(t, node2.Client().Call(&targetInfo, "admin_nodeInfo"), "get node info")
+
+	var peerAdded bool
+	require.NoError(t, node1.Client().Call(&peerAdded, "admin_addPeer", targetInfo.Enode), "add peer")
+	require.True(t, peerAdded, "should have added peer successfully")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	err := wait.For(ctx, time.Second, func() (bool, error) {
+		var peerCount hexutil.Uint64
+		if err := node1.Client().Call(&peerCount, "net_peerCount"); err != nil {
+			return false, err
+		}
+		t.Logf("Peer count %v", uint64(peerCount))
+		return peerCount >= hexutil.Uint64(1), nil
+	})
+	require.NoError(t, err, "wait for a peer to be connected")
+}
+
+func WithP2P() func(ethCfg *ethconfig.Config, nodeCfg *node.Config) error {
+	return func(ethCfg *ethconfig.Config, nodeCfg *node.Config) error {
+		ethCfg.RollupDisableTxPoolGossip = false
+		nodeCfg.P2P = p2p.Config{
+			NoDiscovery: true,
+			ListenAddr:  "127.0.0.1:0",
+			MaxPeers:    10,
+		}
+		return nil
+	}
+}