build(deps): bump github.com/hashicorp/golang-lru/v2 from 2.0.2 to 2.0.7

.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,13 +1242,15 @@ workflows:
             - op-batcher-tests
             - op-bindings-tests
             - op-chain-ops-tests
+            - op-heartbeat-tests
             - op-node-tests
             - op-proposer-tests
             - op-challenger-tests
             - op-program-tests
             - 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

README.md

@@ -57,6 +57,7 @@ Refer to the Directory Structure section below to understand which packages are
 ├── <a href="./op-exporter">op-exporter</a>: Prometheus exporter client
 ├── <a href="./op-heartbeat">op-heartbeat</a>: Heartbeat monitor service
 ├── <a href="./op-node">op-node</a>: rollup consensus-layer client
+├── <a href="./op-preimage">op-preimage</a>: Go bindings for Preimage Oracle
 ├── <a href="./op-program">op-program</a>: Fault proof program
 ├── <a href="./op-proposer">op-proposer</a>: L2-Output Submitter, submits proposals to L1
 ├── <a href="./op-service">op-service</a>: Common codebase utilities

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/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")

codecov.yml

@@ -1,7 +1,4 @@
-comment:
-  layout: "reach, diff, flags, files"
-  behavior: default
-  require_changes: true    # only post the comment if coverage changes
+comment: false
 ignore:
   - "op-e2e"
   - "**/*.t.sol"

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

@@ -0,0 +1,16 @@
+## 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)

docs/fault-proof-alpha/cannon.md

@@ -0,0 +1,92 @@
+## 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

@@ -0,0 +1,24 @@
+## 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.