Merge branch 'develop' into dependabot/npm_and_yarn/vitest-0.34.2

.changeset/tame-doors-invite.md

+---
+'@eth-optimism/common-ts': patch
+---
+
+Updated npm dependencies of common-ts

.circleci/config.yml

@@ -415,6 +415,10 @@ jobs:
             pnpm autogen:invariant-docs
             git diff --exit-code ./invariant-docs/*.md || echo "export INVARIANT_DOCS_STATUS=1" >> "$BASH_ENV"
           working_directory: packages/contracts-bedrock
+      - run:
+          name: check deploy configs || echo "export DEPLOY_CONFIGS_STATUS=1" >> "$BASH_ENV"
+          command: pnpm validate-deploy-configs
+          working_directory: packages/contracts-bedrock
       - run:
           name: check statuses
           command: |
@@ -430,12 +434,16 @@ jobs:
               echo "Storage snapshot failed, see job output for details."
               FAILED=1
             fi
+            if [[ "$SEMVER_LOCK_STATUS" -ne 0 ]]; then
+              echo "Semver lock failed, see job output for details."
+              FAILED=1
+            fi
             if [[ "$INVARIANT_DOCS_STATUS" -ne 0 ]]; then
               echo "Invariant docs failed, see job output for details."
               FAILED=1
             fi
-            if [[ "$SEMVER_LOCK_STATUS" -ne 0 ]]; then
-              echo "Semver lock failed, see job output for details."
+            if [[ "$DEPLOY_CONFIGS_STATUS" -ne 0 ]]; then
+              echo "Deploy config check failed, see job output for details."
               FAILED=1
             fi
             if [[ "$FAILED" -ne 0 ]]; then
@@ -770,6 +778,9 @@ jobs:
       use_http:
         description: If the op-e2e package should use HTTP clients
         type: string
+      use_external:
+        description: The extra-process shim (if any) that should be used
+        type: string
     docker:
       - image: us-docker.pkg.dev/oplabs-tools-artifacts/images/ci-builder:latest
     resource_class: xlarge
@@ -780,6 +791,13 @@ jobs:
       - run:
           name: prep results dir
           command: mkdir -p /tmp/test-results
+      - when:
+          condition: <<parameters.use_external>>
+          steps:
+            - run:
+                name: Build Shim
+                command: make -C <<parameters.use_external>>
+                working_directory: <<parameters.module>>
       - run:
           name: install geth
           command: make install-geth
@@ -799,9 +817,11 @@ jobs:
             # Note: We don't use circle CI test splits because we need to split by test name, not by package. There is an additional
             # constraint that gotestsum does not currently (nor likely will) accept files from different pacakges when building.
             # Note: -parallel must be set to match the number of cores in the resource class
+            export TEST_SUFFIX="<<parameters.use_external>>"
+            export EXTERNAL_L2="$(test -z '<<parameters.use_external>>' || echo '<<parameters.use_external>>/shim')"
             OP_TESTLOG_DISABLE_COLOR=true OP_E2E_DISABLE_PARALLEL=false OP_E2E_USE_HTTP=<<parameters.use_http>>  gotestsum \
-            --format=standard-verbose --junitfile=/tmp/test-results/<<parameters.module>>_http_<<parameters.use_http>>.xml \
-            -- -timeout=20m -parallel=8 ./...
+            --format=standard-verbose --junitfile=/tmp/test-results/<<parameters.module>>_http_<<parameters.use_http>>$TEST_SUFFIX.xml \
+            -- -timeout=20m -parallel=8 --externalL2 "$EXTERNAL_L2" ./...
           working_directory: <<parameters.module>>
       - store_test_results:
           path: /tmp/test-results
@@ -860,7 +880,7 @@ jobs:
           patterns: indexer
       - run:
           name: Lint
-          command: golangci-lint run -E goimports,sqlclosecheck,bodyclose,asciicheck,misspell,errorlint --timeout 2m -e "errors.As" -e "errors.Is" ./...
+          command: golangci-lint run -E goimports,sqlclosecheck,bodyclose,asciicheck,misspell,errorlint --timeout 4m -e "errors.As" -e "errors.Is" ./...
           working_directory: indexer
       - run:
           name: install geth
@@ -1033,59 +1053,6 @@ jobs:
           name: "Go mod tidy"
           command: make mod-tidy && git diff --exit-code
 
-  hive-test:
-    parameters:
-      version:
-        type: string
-        default: develop
-      sim:
-        type: string
-    machine:
-      image: ubuntu-2204:2022.10.2
-      docker_layer_caching: true
-      resource_class: large
-    steps:
-      - attach_workspace:
-          at: /tmp/docker_images
-      - run:
-          name: Docker Load
-          command: |
-            docker load -i /tmp/docker_images/op-batcher_<<parameters.version>>.tar
-            docker load -i /tmp/docker_images/op-proposer_<<parameters.version>>.tar
-            docker load -i /tmp/docker_images/op-node_<<parameters.version>>.tar
-      - run:
-          command: git clone https://github.com/ethereum-optimism/hive.git .
-      - go/load-cache
-      - go/mod-download
-      - go/save-cache
-      - run: { command: "go build ." }
-      - run: { command: "go build junit/junitformatter.go" }
-      - run:
-          command: |
-            ./hive \
-            -sim=<<parameters.sim>> \
-            -sim.loglevel=5 \
-            -client=go-ethereum_v1.11.6,op-geth_optimism,op-proposer_<<parameters.version>>,op-batcher_<<parameters.version>>,op-node_<<parameters.version>> |& tee /tmp/hive.log
-      - run:
-          command: |
-            tar -cvf /tmp/workspace.tgz -C /home/circleci/project /home/circleci/project/workspace
-          name: "Archive workspace"
-          when: always
-      - run:
-          command: |
-            ./junitformatter /home/circleci/project/workspace/logs/*.json > /home/circleci/project/workspace/logs/junit.xml
-          when: always
-      - store_artifacts:
-          path: /tmp/workspace.tgz
-          destination: hive-workspace.tgz
-          when: always
-      - store_test_results:
-          path: /home/circleci/project/workspace/logs/junit.xml
-          when: always
-      - store_artifacts:
-          path: /home/circleci/project/workspace/logs/junit.xml
-          when: always
-
   bedrock-go-tests:
     docker:
       - image: cimg/go:1.20
@@ -1266,10 +1233,17 @@ workflows:
           name: op-e2e-WS-tests
           module: op-e2e
           use_http: "false"
+          use_external: ""
       - go-e2e-test:
           name: op-e2e-HTTP-tests
           module: op-e2e
           use_http: "true"
+          use_external: ""
+      - go-e2e-test:
+          name: op-e2e-WS-tests-external-geth
+          module: op-e2e
+          use_http: "false"
+          use_external: "external_geth"
       - bedrock-go-tests:
           requires:
             - op-batcher-lint
@@ -1396,33 +1370,6 @@ workflows:
           docker_target: wd-mon
           context:
             - oplabs-gcr
-      - hive-test:
-          name: hive-test-rpc
-          version: <<pipeline.git.revision>>
-          sim: optimism/rpc
-          requires:
-            - op-node-docker-build
-            - op-batcher-docker-build
-            - op-proposer-docker-build
-            - op-challenger-docker-build
-      - hive-test:
-          name: hive-test-p2p
-          version: <<pipeline.git.revision>>
-          sim: optimism/p2p
-          requires:
-            - op-node-docker-build
-            - op-batcher-docker-build
-            - op-proposer-docker-build
-            - op-challenger-docker-build
-      - hive-test:
-          name: hive-test-l1ops
-          version: <<pipeline.git.revision>>
-          sim: optimism/l1ops
-          requires:
-            - op-node-docker-build
-            - op-batcher-docker-build
-            - op-proposer-docker-build
-            - op-challenger-docker-build
       - check-generated-mocks-op-node
       - check-generated-mocks-op-service
       - cannon-go-lint-and-test

.github/mergify.yml

@@ -300,7 +300,7 @@ pull_request_rules:
           - A-proxyd
   - name: Add M-docs label
     conditions:
-      - 'files~=^(technical-documents|specs)\/'
+      - 'files~=^(docs|specs)\/'
       - '#label<5'
     actions:
       label:

README.md

-
 <div align="center">
   <br />
   <br />
@@ -48,13 +47,7 @@ Refer to the Directory Structure section below to understand which packages are
 ## Directory Structure
 
 <pre>
-~~ Production ~~
-├── <a href="./packages">packages</a>
-│   ├── <a href="./packages/common-ts">common-ts</a>: Common tools for building apps in TypeScript
-│   ├── <a href="./packages/contracts-bedrock">contracts-bedrock</a>: Bedrock smart contracts.
-│   ├── <a href="./packages/core-utils">core-utils</a>: Low-level utilities that make building Optimism easier
-│   ├── <a href="./packages/chain-mon">chain-mon</a>: Chain monitoring services
-│   └── <a href="./packages/sdk">sdk</a>: provides a set of tools for interacting with Optimism
+├── <a href="./docs">docs</a>: A collection of documents including audits and post-mortems
 ├── <a href="./op-bindings">op-bindings</a>: Go bindings for Bedrock smart contracts.
 ├── <a href="./op-batcher">op-batcher</a>: L2-Batch Submitter, submits bundles of batches to L1
 ├── <a href="./op-bootnode">op-bootnode</a>: Standalone op-node discovery bootnode
@@ -70,19 +63,15 @@ Refer to the Directory Structure section below to understand which packages are
 ├── <a href="./op-signer">op-signer</a>: Client signer
 ├── <a href="./op-wheel">op-wheel</a>: Database utilities
 ├── <a href="./ops-bedrock">ops-bedrock</a>: Bedrock devnet work
-├── <a href="./proxyd">proxyd</a>: Configurable RPC request router and proxy
-└── <a href="./specs">specs</a>: Specs of the rollup starting at the Bedrock upgrade
-
-~~ Pre-BEDROCK ~~
 ├── <a href="./packages">packages</a>
+│   ├── <a href="./packages/chain-mon">chain-mon</a>: Chain monitoring services
 │   ├── <a href="./packages/common-ts">common-ts</a>: Common tools for building apps in TypeScript
+│   ├── <a href="./packages/contracts-ts">contracts-ts</a>: ABI and Address constants
+│   ├── <a href="./packages/contracts-bedrock">contracts-bedrock</a>: Bedrock smart contracts
 │   ├── <a href="./packages/core-utils">core-utils</a>: Low-level utilities that make building Optimism easier
-│   ├── <a href="./packages/chain-mon">chain-mon</a>: Chain monitoring services
 │   └── <a href="./packages/sdk">sdk</a>: provides a set of tools for interacting with Optimism
-├── <a href="./indexer">indexer</a>: indexes and syncs transactions
-├── <a href="./op-exporter">op-exporter</a>: A prometheus exporter to collect/serve metrics from an Optimism node
 ├── <a href="./proxyd">proxyd</a>: Configurable RPC request router and proxy
-└── <a href="./technical-documents">technical-documents</a>: audits and post-mortem documents
+└── <a href="./specs">specs</a>: Specs of the rollup starting at the Bedrock upgrade
 </pre>
 
 ## Branching Model

cannon/mipsevm/mips.go

@@ -395,87 +395,110 @@ func (m *InstrumentedState) mipsStep() error {
 
 func execute(insn uint32, rs uint32, rt uint32, mem uint32) uint32 {
 	opcode := insn >> 26 // 6-bits
-	fun := insn & 0x3f   // 6-bits
-
-	if opcode < 0x20 {
-		// transform ArithLogI
-		// TODO(CLI-4136): replace with table
-		if opcode >= 8 && opcode < 0xF {
-			switch opcode {
-			case 8:
-				fun = 0x20 // addi
-			case 9:
-				fun = 0x21 // addiu
-			case 0xA:
-				fun = 0x2A // slti
-			case 0xB:
-				fun = 0x2B // sltiu
-			case 0xC:
-				fun = 0x24 // andi
-			case 0xD:
-				fun = 0x25 // ori
-			case 0xE:
-				fun = 0x26 // xori
-			}
-			opcode = 0
+
+	if opcode == 0 || (opcode >= 8 && opcode < 0xF) {
+		fun := insn & 0x3f // 6-bits
+		// transform ArithLogI to SPECIAL
+		switch opcode {
+		case 8:
+			fun = 0x20 // addi
+		case 9:
+			fun = 0x21 // addiu
+		case 0xA:
+			fun = 0x2A // slti
+		case 0xB:
+			fun = 0x2B // sltiu
+		case 0xC:
+			fun = 0x24 // andi
+		case 0xD:
+			fun = 0x25 // ori
+		case 0xE:
+			fun = 0x26 // xori
 		}
 
-		// 0 is opcode SPECIAL
-		if opcode == 0 {
+		switch fun {
+		case 0x00: // sll
+			return rt << ((insn >> 6) & 0x1F)
+		case 0x02: // srl
+			return rt >> ((insn >> 6) & 0x1F)
+		case 0x03: // sra
 			shamt := (insn >> 6) & 0x1F
-			if fun < 0x20 {
-				switch {
-				case fun >= 0x08:
-					return rs // jr/jalr/div + others
-				case fun == 0x00:
-					return rt << shamt // sll
-				case fun == 0x02:
-					return rt >> shamt // srl
-				case fun == 0x03:
-					return SE(rt>>shamt, 32-shamt) // sra
-				case fun == 0x04:
-					return rt << (rs & 0x1F) // sllv
-				case fun == 0x06:
-					return rt >> (rs & 0x1F) // srlv
-				case fun == 0x07:
-					return SE(rt>>rs, 32-rs) // srav
-				}
+			return SE(rt>>shamt, 32-shamt)
+		case 0x04: // sllv
+			return rt << (rs & 0x1F)
+		case 0x06: // srlv
+			return rt >> (rs & 0x1F)
+		case 0x07: // srav
+			return SE(rt>>rs, 32-rs)
+		// functs in range [0x8, 0x1b] are handled specially by other functions
+		case 0x08: // jr
+			return rs
+		case 0x09: // jalr
+			return rs
+		case 0x0a: // movz
+			return rs
+		case 0x0b: // movn
+			return rs
+		case 0x0c: // syscall
+			return rs
+		// 0x0d - break not supported
+		case 0x0f: // sync
+			return rs
+		case 0x10: // mfhi
+			return rs
+		case 0x11: // mthi
+			return rs
+		case 0x12: // mflo
+			return rs
+		case 0x13: // mtlo
+			return rs
+		case 0x18: // mult
+			return rs
+		case 0x19: // multu
+			return rs
+		case 0x1a: // div
+			return rs
+		case 0x1b: // divu
+			return rs
+		// The rest includes transformed R-type arith imm instructions
+		case 0x20: // add
+			return rs + rt
+		case 0x21: // addu
+			return rs + rt
+		case 0x22: // sub
+			return rs - rt
+		case 0x23: // subu
+			return rs - rt
+		case 0x24: // and
+			return rs & rt
+		case 0x25: // or
+			return rs | rt
+		case 0x26: // xor
+			return rs ^ rt
+		case 0x27: // nor
+			return ^(rs | rt)
+		case 0x2a: // slti
+			if int32(rs) < int32(rt) {
+				return 1
 			}
-			// 0x10-0x13 = mfhi, mthi, mflo, mtlo
-			// R-type (ArithLog)
-			switch fun {
-			case 0x20, 0x21:
-				return rs + rt // add or addu
-			case 0x22, 0x23:
-				return rs - rt // sub or subu
-			case 0x24:
-				return rs & rt // and
-			case 0x25:
-				return rs | rt // or
-			case 0x26:
-				return rs ^ rt // xor
-			case 0x27:
-				return ^(rs | rt) // nor
-			case 0x2A:
-				if int32(rs) < int32(rt) {
-					return 1 // slt
-				} else {
-					return 0
-				}
-			case 0x2B:
-				if rs < rt {
-					return 1 // sltu
-				} else {
-					return 0
-				}
+			return 0
+		case 0x2b: // sltiu
+			if rs < rt {
+				return 1
 			}
-		} else if opcode == 0xF {
-			return rt << 16 // lui
-		} else if opcode == 0x1C { // SPECIAL2
-			if fun == 2 { // mul
+			return 0
+		default:
+			panic("invalid instruction")
+		}
+	} else {
+		switch opcode {
+		// SPECIAL2
+		case 0x1C:
+			fun := insn & 0x3f // 6-bits
+			switch fun {
+			case 0x2: // mul
 				return uint32(int32(rs) * int32(rt))
-			}
-			if fun == 0x20 || fun == 0x21 { // clo
+			case 0x20, 0x21: // clo
 				if fun == 0x20 {
 					rs = ^rs
 				}
@@ -485,9 +508,8 @@ func execute(insn uint32, rs uint32, rt uint32, mem uint32) uint32 {
 				}
 				return i
 			}
-		}
-	} else if opcode < 0x28 {
-		switch opcode {
+		case 0x0F: // lui
+			return rt << 16
 		case 0x20: // lb
 			return SE((mem>>(24-(rs&3)*8))&0xFF, 8)
 		case 0x21: // lh
@@ -500,37 +522,38 @@ func execute(insn uint32, rs uint32, rt uint32, mem uint32) uint32 {
 			return mem
 		case 0x24: // lbu
 			return (mem >> (24 - (rs&3)*8)) & 0xFF
-		case 0x25: // lhu
+		case 0x25: //  lhu
 			return (mem >> (16 - (rs&2)*8)) & 0xFFFF
-		case 0x26: // lwr
+		case 0x26: //  lwr
 			val := mem >> (24 - (rs&3)*8)
 			mask := uint32(0xFFFFFFFF) >> (24 - (rs&3)*8)
 			return (rt & ^mask) | val
+		case 0x28: //  sb
+			val := (rt & 0xFF) << (24 - (rs&3)*8)
+			mask := 0xFFFFFFFF ^ uint32(0xFF<<(24-(rs&3)*8))
+			return (mem & mask) | val
+		case 0x29: //  sh
+			val := (rt & 0xFFFF) << (16 - (rs&2)*8)
+			mask := 0xFFFFFFFF ^ uint32(0xFFFF<<(16-(rs&2)*8))
+			return (mem & mask) | val
+		case 0x2a: //  swl
+			val := rt >> ((rs & 3) * 8)
+			mask := uint32(0xFFFFFFFF) >> ((rs & 3) * 8)
+			return (mem & ^mask) | val
+		case 0x2b: //  sw
+			return rt
+		case 0x2e: //  swr
+			val := rt << (24 - (rs&3)*8)
+			mask := uint32(0xFFFFFFFF) << (24 - (rs&3)*8)
+			return (mem & ^mask) | val
+		case 0x30: //  ll
+			return mem
+		case 0x38: //  sc
+			return rt
+		default:
+			panic("invalid instruction")
 		}
-	} else if opcode == 0x28 { // sb
-		val := (rt & 0xFF) << (24 - (rs&3)*8)
-		mask := 0xFFFFFFFF ^ uint32(0xFF<<(24-(rs&3)*8))
-		return (mem & mask) | val
-	} else if opcode == 0x29 { // sh
-		val := (rt & 0xFFFF) << (16 - (rs&2)*8)
-		mask := 0xFFFFFFFF ^ uint32(0xFFFF<<(16-(rs&2)*8))
-		return (mem & mask) | val
-	} else if opcode == 0x2a { // swl
-		val := rt >> ((rs & 3) * 8)
-		mask := uint32(0xFFFFFFFF) >> ((rs & 3) * 8)
-		return (mem & ^mask) | val
-	} else if opcode == 0x2b { // sw
-		return rt
-	} else if opcode == 0x2e { // swr
-		val := rt << (24 - (rs&3)*8)
-		mask := uint32(0xFFFFFFFF) << (24 - (rs&3)*8)
-		return (mem & ^mask) | val
-	} else if opcode == 0x30 {
-		return mem // ll
-	} else if opcode == 0x38 {
-		return rt // sc
 	}
-
 	panic("invalid instruction")
 }
 

docs/README.md

+## Optimism Monorepo Documentation
+
+The `docs/` directory contains Optimism documentation closely tied to the implementation details of the monorepo (https://github.com/ethereum-optimism/optimism).
+
+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.

go.mod

@@ -8,6 +8,7 @@ require (
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0
 	github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3
+	github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20230817174831-5d3ca1966435
 	github.com/ethereum/go-ethereum v1.12.0
 	github.com/fsnotify/fsnotify v1.6.0
 	github.com/go-chi/chi/v5 v5.0.10
@@ -15,9 +16,8 @@ require (
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb
 	github.com/google/go-cmp v0.5.9
 	github.com/google/gofuzz v1.2.1-0.20220503160820-4a35382e8fc8
-	github.com/google/uuid v1.3.0
+	github.com/google/uuid v1.3.1
 	github.com/hashicorp/go-multierror v1.1.1
-	github.com/hashicorp/golang-lru v1.0.2
 	github.com/hashicorp/golang-lru/v2 v2.0.2
 	github.com/holiman/uint256 v1.2.3
 	github.com/ipfs/go-datastore v0.6.0
@@ -32,6 +32,7 @@ require (
 	github.com/multiformats/go-multiaddr v0.10.1
 	github.com/multiformats/go-multiaddr-dns v0.3.1
 	github.com/olekukonko/tablewriter v0.0.5
+	github.com/onsi/gomega v1.27.10
 	github.com/pkg/errors v0.9.1
 	github.com/pkg/profile v1.7.0
 	github.com/prometheus/client_golang v1.14.0
@@ -43,7 +44,7 @@ require (
 	golang.org/x/term v0.11.0
 	golang.org/x/time v0.3.0
 	gorm.io/driver/postgres v1.5.2
-	gorm.io/gorm v1.25.3
+	gorm.io/gorm v1.25.4
 )
 
 require (
@@ -66,23 +67,29 @@ require (
 	github.com/containerd/cgroups v1.1.0 // indirect
 	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
+	github.com/crate-crypto/go-ipa v0.0.0-20220523130400-f11357ae11c7 // indirect
 	github.com/crate-crypto/go-kzg-4844 v0.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c // indirect
 	github.com/deckarep/golang-set/v2 v2.1.0 // indirect
 	github.com/decred/dcrd/crypto/blake256 v1.0.0 // indirect
 	github.com/deepmap/oapi-codegen v1.8.2 // indirect
+	github.com/dlclark/regexp2 v1.7.0 // indirect
 	github.com/docker/docker v20.10.24+incompatible // indirect
 	github.com/docker/go-units v0.5.0 // indirect
+	github.com/dop251/goja v0.0.0-20230122112309-96b1610dd4f7 // indirect
 	github.com/elastic/gosigar v0.14.2 // indirect
 	github.com/ethereum/c-kzg-4844 v0.2.0 // indirect
+	github.com/fatih/color v1.7.0 // indirect
 	github.com/felixge/fgprof v0.9.3 // indirect
 	github.com/fjl/memsize v0.0.1 // indirect
 	github.com/flynn/noise v1.0.0 // indirect
 	github.com/francoispqt/gojay v1.2.13 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 // indirect
+	github.com/gballet/go-verkle v0.0.0-20220902153445-097bd83b7732 // indirect
 	github.com/getsentry/sentry-go v0.18.0 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
 	github.com/godbus/dbus/v5 v5.1.0 // indirect
@@ -110,8 +117,10 @@ require (
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/jbenet/go-temp-err-catcher v0.1.0 // indirect
 	github.com/jbenet/goprocess v0.1.4 // indirect
+	github.com/jedisct1/go-minisign v0.0.0-20190909160543-45766022959e // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/karalabe/usb v0.0.2 // indirect
 	github.com/klauspost/compress v1.16.4 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
 	github.com/koron/go-ssdp v0.0.4 // indirect
@@ -147,7 +156,9 @@ require (
 	github.com/multiformats/go-multihash v0.2.1 // indirect
 	github.com/multiformats/go-multistream v0.4.1 // indirect
 	github.com/multiformats/go-varint v0.0.7 // indirect
-	github.com/onsi/ginkgo/v2 v2.9.2 // indirect
+	github.com/naoina/go-stringutil v0.1.0 // indirect
+	github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416 // indirect
+	github.com/onsi/ginkgo/v2 v2.11.0 // indirect
 	github.com/opencontainers/runtime-spec v1.0.2 // indirect
 	github.com/opentracing/opentracing-go v1.2.0 // indirect
 	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect
@@ -183,10 +194,10 @@ require (
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.24.0 // indirect
 	golang.org/x/mod v0.11.0 // indirect
-	golang.org/x/net v0.10.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/tools v0.7.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
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
@@ -197,6 +208,6 @@ require (
 	rsc.io/tmplfunc v0.0.3 // indirect
 )
 
-replace github.com/ethereum/go-ethereum v1.12.0 => github.com/ethereum-optimism/op-geth v1.101106.1-0.20230724181546-b9c6d36ae9b8
+replace github.com/ethereum/go-ethereum v1.12.0 => github.com/ethereum-optimism/op-geth v1.101200.0-rc.1.0.20230818191139-f7376a28049b
 
 //replace github.com/ethereum/go-ethereum v1.12.0 => ../go-ethereum

indexer/api/api_test.go

@@ -56,7 +56,7 @@ func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalWithFilter(filter database
 
 func (mbv *MockBridgeTransfersView) L1BridgeDepositsByAddress(address common.Address, cursor string, limit int) (*database.L1BridgeDepositsResponse, error) {
 	return &database.L1BridgeDepositsResponse{
-		Deposits: []*database.L1BridgeDepositWithTransactionHashes{
+		Deposits: []database.L1BridgeDepositWithTransactionHashes{
 			{
 				L1BridgeDeposit:   deposit,
 				L1TransactionHash: common.HexToHash("0x123"),
@@ -67,7 +67,7 @@ func (mbv *MockBridgeTransfersView) L1BridgeDepositsByAddress(address common.Add
 
 func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalsByAddress(address common.Address, cursor string, limit int) (*database.L2BridgeWithdrawalsResponse, error) {
 	return &database.L2BridgeWithdrawalsResponse{
-		Withdrawals: []*database.L2BridgeWithdrawalWithTransactionHashes{
+		Withdrawals: []database.L2BridgeWithdrawalWithTransactionHashes{
 			{
 				L2BridgeWithdrawal: withdrawal,
 				L2TransactionHash:  common.HexToHash("0x789"),

indexer/cli/cli.go

@@ -40,7 +40,7 @@ func runIndexer(ctx *cli.Context) error {
 		return err
 	}
 
-	indexer, err := indexer.NewIndexer(cfg.Chain, cfg.RPCs, db, logger)
+	indexer, err := indexer.NewIndexer(logger, cfg.Chain, cfg.RPCs, db)
 	if err != nil {
 		return err
 	}
@@ -105,7 +105,7 @@ func NewCli(GitVersion string, GitCommit string, GitDate string) *Cli {
 				Action:      runApi,
 			},
 			{
-				Name:        "indexer",
+				Name:        "index",
 				Flags:       flags,
 				Description: "Runs the indexing service",
 				Action:      runIndexer,

indexer/config/config.go

@@ -3,7 +3,6 @@ package config
 import (
 	"fmt"
 	"os"
-	"reflect"
 
 	"github.com/BurntSushi/toml"
 	"github.com/ethereum/go-ethereum/common"
@@ -23,31 +22,18 @@ type Config struct {
 
 // fetch this via onchain config from RPCsConfig and remove from config in future
 type L1Contracts struct {
-	OptimismPortal         common.Address `toml:"optimism-portal"`
-	L2OutputOracle         common.Address `toml:"l2-output-oracle"`
-	L1CrossDomainMessenger common.Address `toml:"l1-cross-domain-messenger"`
-	L1StandardBridge       common.Address `toml:"l1-standard-bridge"`
-	L1ERC721Bridge         common.Address `toml:"l1-erc721-bridge"`
+	OptimismPortalProxy         common.Address `toml:"optimism-portal"`
+	L2OutputOracleProxy         common.Address `toml:"l2-output-oracle"`
+	L1CrossDomainMessengerProxy common.Address `toml:"l1-cross-domain-messenger"`
+	L1StandardBridgeProxy       common.Address `toml:"l1-standard-bridge"`
 
-	// Some more contracts -- ProxyAdmin, SystemConfig, etcc
+	// Some more contracts -- L1ERC721Bridge, ProxyAdmin, SystemConfig, etc
 	// Ignore the auxiliary contracts?
 
 	// Legacy contracts? We'll add this in to index the legacy chain.
 	// Remove afterwards?
 }
 
-func (c L1Contracts) ToSlice() []common.Address {
-	fields := reflect.VisibleFields(reflect.TypeOf(c))
-	v := reflect.ValueOf(c)
-
-	contracts := make([]common.Address, len(fields))
-	for i, field := range fields {
-		contracts[i] = (v.FieldByName(field.Name).Interface()).(common.Address)
-	}
-
-	return contracts
-}
-
 // ChainConfig configures of the chain being indexed
 type ChainConfig struct {
 	// Configure known chains with the l2 chain id

indexer/config/config_test.go

@@ -54,11 +54,10 @@ func TestLoadConfig(t *testing.T) {
 	require.NoError(t, err)
 
 	require.Equal(t, conf.Chain.Preset, 420)
-	require.Equal(t, conf.Chain.L1Contracts.OptimismPortal.String(), presetL1Contracts[420].OptimismPortal.String())
-	require.Equal(t, conf.Chain.L1Contracts.L1CrossDomainMessenger.String(), presetL1Contracts[420].L1CrossDomainMessenger.String())
-	require.Equal(t, conf.Chain.L1Contracts.L1ERC721Bridge.String(), presetL1Contracts[420].L1ERC721Bridge.String())
-	require.Equal(t, conf.Chain.L1Contracts.L1StandardBridge.String(), presetL1Contracts[420].L1StandardBridge.String())
-	require.Equal(t, conf.Chain.L1Contracts.L2OutputOracle.String(), presetL1Contracts[420].L2OutputOracle.String())
+	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.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")
@@ -85,7 +84,6 @@ func TestLoadConfig_WithoutPreset(t *testing.T) {
 		l2-output-oracle = "0x42097868233d1aa22e815a266982f2cf17685a27"
 		l1-cross-domain-messenger = "0x420ce71c97B33Cc4729CF772ae268934F7ab5fA1"
 		l1-standard-bridge = "0x4209fc46f92E8a1c0deC1b1747d010903E884bE1"
-		l1-erc721-bridge = "0x420749f83b81B301cAb5f48EB8516B986DAef23D"
 
         [rpcs]
         l1-rpc = "https://l1.example.com"
@@ -104,11 +102,10 @@ func TestLoadConfig_WithoutPreset(t *testing.T) {
 	conf, err := LoadConfig(logger, tmpfile.Name())
 	require.NoError(t, err)
 
-	require.Equal(t, conf.Chain.L1Contracts.OptimismPortal.String(), common.HexToAddress("0x4205Fc579115071764c7423A4f12eDde41f106Ed").String())
-	require.Equal(t, conf.Chain.L1Contracts.L2OutputOracle.String(), common.HexToAddress("0x42097868233d1aa22e815a266982f2cf17685a27").String())
-	require.Equal(t, conf.Chain.L1Contracts.L1CrossDomainMessenger.String(), common.HexToAddress("0x420ce71c97B33Cc4729CF772ae268934F7ab5fA1").String())
-	require.Equal(t, conf.Chain.L1Contracts.L1StandardBridge.String(), common.HexToAddress("0x4209fc46f92E8a1c0deC1b1747d010903E884bE1").String())
-	require.Equal(t, conf.Chain.L1Contracts.L1ERC721Bridge.String(), common.HexToAddress("0x420749f83b81B301cAb5f48EB8516B986DAef23D").String())
+	require.Equal(t, conf.Chain.L1Contracts.OptimismPortalProxy.String(), common.HexToAddress("0x4205Fc579115071764c7423A4f12eDde41f106Ed").String())
+	require.Equal(t, conf.Chain.L1Contracts.L2OutputOracleProxy.String(), common.HexToAddress("0x42097868233d1aa22e815a266982f2cf17685a27").String())
+	require.Equal(t, conf.Chain.L1Contracts.L1CrossDomainMessengerProxy.String(), common.HexToAddress("0x420ce71c97B33Cc4729CF772ae268934F7ab5fA1").String())
+	require.Equal(t, conf.Chain.L1Contracts.L1StandardBridgeProxy.String(), common.HexToAddress("0x4209fc46f92E8a1c0deC1b1747d010903E884bE1").String())
 	require.Equal(t, conf.Chain.Preset, 0)
 }
 

indexer/config/presets.go

@@ -10,54 +10,44 @@ import (
 var presetL1Contracts = map[int]L1Contracts{
 	// OP Mainnet
 	10: {
-		OptimismPortal:         common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
-		L2OutputOracle:         common.HexToAddress("0xdfe97868233d1aa22e815a266982f2cf17685a27"),
-		L1CrossDomainMessenger: common.HexToAddress("0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1"),
-		L1StandardBridge:       common.HexToAddress("0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"),
-		L1ERC721Bridge:         common.HexToAddress("0x5a7749f83b81B301cAb5f48EB8516B986DAef23D"),
+		OptimismPortalProxy:         common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
+		L2OutputOracleProxy:         common.HexToAddress("0xdfe97868233d1aa22e815a266982f2cf17685a27"),
+		L1CrossDomainMessengerProxy: common.HexToAddress("0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1"),
+		L1StandardBridgeProxy:       common.HexToAddress("0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"),
 	},
 	// OP Goerli
 	420: {
-		OptimismPortal:         common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
-		L2OutputOracle:         common.HexToAddress("0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"),
-		L1CrossDomainMessenger: common.HexToAddress("0x5086d1eEF304eb5284A0f6720f79403b4e9bE294"),
-		L1StandardBridge:       common.HexToAddress("0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"),
-		L1ERC721Bridge:         common.HexToAddress("0x8DD330DdE8D9898d43b4dc840Da27A07dF91b3c9"),
+		OptimismPortalProxy:         common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
+		L2OutputOracleProxy:         common.HexToAddress("0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"),
+		L1CrossDomainMessengerProxy: common.HexToAddress("0x5086d1eEF304eb5284A0f6720f79403b4e9bE294"),
+		L1StandardBridgeProxy:       common.HexToAddress("0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"),
 	},
 	// Base Mainnet
 	8453: {
-		OptimismPortal:         common.HexToAddress("0x49048044D57e1C92A77f79988d21Fa8fAF74E97e"),
-		L2OutputOracle:         common.HexToAddress("0x56315b90c40730925ec5485cf004d835058518A0"),
-		L1CrossDomainMessenger: common.HexToAddress("0x866E82a600A1414e583f7F13623F1aC5d58b0Afa"),
-		L1StandardBridge:       common.HexToAddress("0x3154Cf16ccdb4C6d922629664174b904d80F2C35"),
-		// FIXME update this to the correct address
-		L1ERC721Bridge: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+		OptimismPortalProxy:         common.HexToAddress("0x49048044D57e1C92A77f79988d21Fa8fAF74E97e"),
+		L2OutputOracleProxy:         common.HexToAddress("0x56315b90c40730925ec5485cf004d835058518A0"),
+		L1CrossDomainMessengerProxy: common.HexToAddress("0x866E82a600A1414e583f7F13623F1aC5d58b0Afa"),
+		L1StandardBridgeProxy:       common.HexToAddress("0x3154Cf16ccdb4C6d922629664174b904d80F2C35"),
 	},
 	// Base Goerli
 	84531: {
-		OptimismPortal:         common.HexToAddress("0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"),
-		L2OutputOracle:         common.HexToAddress("0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"),
-		L1CrossDomainMessenger: common.HexToAddress("0x8e5693140eA606bcEB98761d9beB1BC87383706D"),
-		L1StandardBridge:       common.HexToAddress("0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"),
-		// FIXME update this to the correct address
-		L1ERC721Bridge: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+		OptimismPortalProxy:         common.HexToAddress("0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"),
+		L2OutputOracleProxy:         common.HexToAddress("0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"),
+		L1CrossDomainMessengerProxy: common.HexToAddress("0x8e5693140eA606bcEB98761d9beB1BC87383706D"),
+		L1StandardBridgeProxy:       common.HexToAddress("0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"),
 	},
 	// Zora mainnet
 	7777777: {
-		OptimismPortal:         common.HexToAddress("0x1a0ad011913A150f69f6A19DF447A0CfD9551054"),
-		L2OutputOracle:         common.HexToAddress("0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"),
-		L1CrossDomainMessenger: common.HexToAddress("0xdC40a14d9abd6F410226f1E6de71aE03441ca506"),
-		L1StandardBridge:       common.HexToAddress("0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"),
-		// FIXME update this to the correct address
-		L1ERC721Bridge: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+		OptimismPortalProxy:         common.HexToAddress("0x1a0ad011913A150f69f6A19DF447A0CfD9551054"),
+		L2OutputOracleProxy:         common.HexToAddress("0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"),
+		L1CrossDomainMessengerProxy: common.HexToAddress("0xdC40a14d9abd6F410226f1E6de71aE03441ca506"),
+		L1StandardBridgeProxy:       common.HexToAddress("0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"),
 	},
 	// Zora goerli
 	999: {
-		OptimismPortal:         common.HexToAddress("0xDb9F51790365e7dc196e7D072728df39Be958ACe"),
-		L2OutputOracle:         common.HexToAddress("0xdD292C9eEd00f6A32Ff5245d0BCd7f2a15f24e00"),
-		L1CrossDomainMessenger: common.HexToAddress("0xD87342e16352D33170557A7dA1e5fB966a60FafC"),
-		L1StandardBridge:       common.HexToAddress("0x7CC09AC2452D6555d5e0C213Ab9E2d44eFbFc956"),
-		// FIXME update this to the correct address
-		L1ERC721Bridge: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+		OptimismPortalProxy:         common.HexToAddress("0xDb9F51790365e7dc196e7D072728df39Be958ACe"),
+		L2OutputOracleProxy:         common.HexToAddress("0xdD292C9eEd00f6A32Ff5245d0BCd7f2a15f24e00"),
+		L1CrossDomainMessengerProxy: common.HexToAddress("0xD87342e16352D33170557A7dA1e5fB966a60FafC"),
+		L1StandardBridgeProxy:       common.HexToAddress("0x7CC09AC2452D6555d5e0C213Ab9E2d44eFbFc956"),
 	},
 }

indexer/database/blocks.go

@@ -18,8 +18,8 @@ import (
  */
 
 type BlockHeader struct {
-	Hash       common.Hash `gorm:"primaryKey;serializer:json"`
-	ParentHash common.Hash `gorm:"serializer:json"`
+	Hash       common.Hash `gorm:"primaryKey;serializer:bytes"`
+	ParentHash common.Hash `gorm:"serializer:bytes"`
 	Number     U256
 	Timestamp  uint64
 
@@ -38,11 +38,11 @@ func BlockHeaderFromHeader(header *types.Header) BlockHeader {
 }
 
 type L1BlockHeader struct {
-	BlockHeader
+	BlockHeader `gorm:"embedded"`
 }
 
 type L2BlockHeader struct {
-	BlockHeader
+	BlockHeader `gorm:"embedded"`
 }
 
 type LegacyStateBatch struct {
@@ -50,14 +50,14 @@ type LegacyStateBatch struct {
 	// violating the primary key constraint.
 	Index uint64 `gorm:"primaryKey;default:0"`
 
-	Root                common.Hash `gorm:"serializer:json"`
+	Root                common.Hash `gorm:"serializer:bytes"`
 	Size                uint64
 	PrevTotal           uint64
 	L1ContractEventGUID uuid.UUID
 }
 
 type OutputProposal struct {
-	OutputRoot    common.Hash `gorm:"primaryKey;serializer:json"`
+	OutputRoot    common.Hash `gorm:"primaryKey;serializer:bytes"`
 	L2OutputIndex U256
 	L2BlockNumber U256
 
@@ -65,24 +65,28 @@ type OutputProposal struct {
 }
 
 type BlocksView interface {
-	L1BlockHeader(*big.Int) (*L1BlockHeader, error)
-	LatestL1BlockHeader() (*L1BlockHeader, error)
+	L1BlockHeader(common.Hash) (*L1BlockHeader, error)
+	L1BlockHeaderWithFilter(BlockHeader) (*L1BlockHeader, error)
+	L1LatestBlockHeader() (*L1BlockHeader, error)
+
+	L2BlockHeader(common.Hash) (*L2BlockHeader, error)
+	L2BlockHeaderWithFilter(BlockHeader) (*L2BlockHeader, error)
+	L2LatestBlockHeader() (*L2BlockHeader, error)
 
 	LatestCheckpointedOutput() (*OutputProposal, error)
 	OutputProposal(index *big.Int) (*OutputProposal, error)
 
-	L2BlockHeader(*big.Int) (*L2BlockHeader, error)
-	LatestL2BlockHeader() (*L2BlockHeader, error)
+	LatestEpoch() (*Epoch, error)
 }
 
 type BlocksDB interface {
 	BlocksView
 
-	StoreL1BlockHeaders([]*L1BlockHeader) error
-	StoreL2BlockHeaders([]*L2BlockHeader) error
+	StoreL1BlockHeaders([]L1BlockHeader) error
+	StoreL2BlockHeaders([]L2BlockHeader) error
 
-	StoreLegacyStateBatches([]*LegacyStateBatch) error
-	StoreOutputProposals([]*OutputProposal) error
+	StoreLegacyStateBatches([]LegacyStateBatch) error
+	StoreOutputProposals([]OutputProposal) error
 }
 
 /**
@@ -99,36 +103,39 @@ func newBlocksDB(db *gorm.DB) BlocksDB {
 
 // L1
 
-func (db *blocksDB) StoreL1BlockHeaders(headers []*L1BlockHeader) error {
+func (db *blocksDB) StoreL1BlockHeaders(headers []L1BlockHeader) error {
 	result := db.gorm.Create(&headers)
 	return result.Error
 }
 
-func (db *blocksDB) StoreLegacyStateBatches(stateBatches []*LegacyStateBatch) error {
+func (db *blocksDB) StoreLegacyStateBatches(stateBatches []LegacyStateBatch) error {
 	result := db.gorm.Create(stateBatches)
 	return result.Error
 }
 
-func (db *blocksDB) StoreOutputProposals(outputs []*OutputProposal) error {
+func (db *blocksDB) StoreOutputProposals(outputs []OutputProposal) error {
 	result := db.gorm.Create(outputs)
 	return result.Error
 }
 
-func (db *blocksDB) L1BlockHeader(height *big.Int) (*L1BlockHeader, error) {
+func (db *blocksDB) L1BlockHeader(hash common.Hash) (*L1BlockHeader, error) {
+	return db.L1BlockHeaderWithFilter(BlockHeader{Hash: hash})
+}
+
+func (db *blocksDB) L1BlockHeaderWithFilter(filter BlockHeader) (*L1BlockHeader, error) {
 	var l1Header L1BlockHeader
-	result := db.gorm.Where(&BlockHeader{Number: U256{Int: height}}).Take(&l1Header)
+	result := db.gorm.Where(&filter).Take(&l1Header)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
 	return &l1Header, nil
 }
 
-func (db *blocksDB) LatestL1BlockHeader() (*L1BlockHeader, error) {
+func (db *blocksDB) L1LatestBlockHeader() (*L1BlockHeader, error) {
 	var l1Header L1BlockHeader
 	result := db.gorm.Order("number DESC").Take(&l1Header)
 	if result.Error != nil {
@@ -172,36 +179,71 @@ func (db *blocksDB) OutputProposal(index *big.Int) (*OutputProposal, error) {
 
 // L2
 
-func (db *blocksDB) StoreL2BlockHeaders(headers []*L2BlockHeader) error {
+func (db *blocksDB) StoreL2BlockHeaders(headers []L2BlockHeader) error {
 	result := db.gorm.Create(&headers)
 	return result.Error
 }
 
-func (db *blocksDB) L2BlockHeader(height *big.Int) (*L2BlockHeader, error) {
+func (db *blocksDB) L2BlockHeader(hash common.Hash) (*L2BlockHeader, error) {
+	return db.L2BlockHeaderWithFilter(BlockHeader{Hash: hash})
+}
+
+func (db *blocksDB) L2BlockHeaderWithFilter(filter BlockHeader) (*L2BlockHeader, error) {
 	var l2Header L2BlockHeader
-	result := db.gorm.Where(&BlockHeader{Number: U256{Int: height}}).Take(&l2Header)
+	result := db.gorm.Where(&filter).Take(&l2Header)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
 	return &l2Header, nil
 }
 
-func (db *blocksDB) LatestL2BlockHeader() (*L2BlockHeader, error) {
+func (db *blocksDB) L2LatestBlockHeader() (*L2BlockHeader, error) {
 	var l2Header L2BlockHeader
 	result := db.gorm.Order("number DESC").Take(&l2Header)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
 	result.Logger.Info(context.Background(), "number ", l2Header.Number)
 	return &l2Header, nil
 }
+
+// Auxiliary Methods on both L1 & L2
+
+type Epoch struct {
+	L1BlockHeader L1BlockHeader `gorm:"embedded"`
+	L2BlockHeader L2BlockHeader `gorm:"embedded"`
+}
+
+// LatestEpoch return the latest epoch, seen on  L1 & L2. In other words
+// this returns the latest indexed L1 block that has a corresponding
+// indexed L2 block with a matching L1Origin (equal timestamps).
+//
+// 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("*")
+
+	var epoch Epoch
+	result := query.Take(&epoch)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &epoch, nil
+}

indexer/database/bridge_messages.go

@@ -16,7 +16,7 @@ import (
  */
 
 type BridgeMessage struct {
-	MessageHash common.Hash `gorm:"primaryKey;serializer:json"`
+	MessageHash common.Hash `gorm:"primaryKey;serializer:bytes"`
 	Nonce       U256
 
 	SentMessageEventGUID    uuid.UUID
@@ -28,12 +28,12 @@ type BridgeMessage struct {
 
 type L1BridgeMessage struct {
 	BridgeMessage         `gorm:"embedded"`
-	TransactionSourceHash common.Hash `gorm:"serializer:json"`
+	TransactionSourceHash common.Hash `gorm:"serializer:bytes"`
 }
 
 type L2BridgeMessage struct {
 	BridgeMessage             `gorm:"embedded"`
-	TransactionWithdrawalHash common.Hash `gorm:"serializer:json"`
+	TransactionWithdrawalHash common.Hash `gorm:"serializer:bytes"`
 }
 
 type BridgeMessagesView interface {
@@ -47,10 +47,10 @@ type BridgeMessagesView interface {
 type BridgeMessagesDB interface {
 	BridgeMessagesView
 
-	StoreL1BridgeMessages([]*L1BridgeMessage) error
+	StoreL1BridgeMessages([]L1BridgeMessage) error
 	MarkRelayedL1BridgeMessage(common.Hash, uuid.UUID) error
 
-	StoreL2BridgeMessages([]*L2BridgeMessage) error
+	StoreL2BridgeMessages([]L2BridgeMessage) error
 	MarkRelayedL2BridgeMessage(common.Hash, uuid.UUID) error
 }
 
@@ -70,7 +70,7 @@ func newBridgeMessagesDB(db *gorm.DB) BridgeMessagesDB {
  * Arbitrary Messages Sent from L1
  */
 
-func (db bridgeMessagesDB) StoreL1BridgeMessages(messages []*L1BridgeMessage) error {
+func (db bridgeMessagesDB) StoreL1BridgeMessages(messages []L1BridgeMessage) error {
 	result := db.gorm.Create(&messages)
 	return result.Error
 }
@@ -109,7 +109,7 @@ func (db bridgeMessagesDB) MarkRelayedL1BridgeMessage(messageHash common.Hash, r
  * Arbitrary Messages Sent from L2
  */
 
-func (db bridgeMessagesDB) StoreL2BridgeMessages(messages []*L2BridgeMessage) error {
+func (db bridgeMessagesDB) StoreL2BridgeMessages(messages []L2BridgeMessage) error {
 	result := db.gorm.Create(&messages)
 	return result.Error
 }

indexer/database/bridge_transactions.go

@@ -8,7 +8,6 @@ import (
 	"gorm.io/gorm"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
 /**
@@ -16,16 +15,16 @@ import (
  */
 
 type Transaction struct {
-	FromAddress common.Address `gorm:"serializer:json"`
-	ToAddress   common.Address `gorm:"serializer:json"`
+	FromAddress common.Address `gorm:"serializer:bytes"`
+	ToAddress   common.Address `gorm:"serializer:bytes"`
 	Amount      U256
-	Data        hexutil.Bytes `gorm:"serializer:json"`
+	Data        Bytes `gorm:"serializer:bytes"`
 	Timestamp   uint64
 }
 
 type L1TransactionDeposit struct {
-	SourceHash           common.Hash `gorm:"serializer:json;primaryKey"`
-	L2TransactionHash    common.Hash `gorm:"serializer:json"`
+	SourceHash           common.Hash `gorm:"serializer:bytes;primaryKey"`
+	L2TransactionHash    common.Hash `gorm:"serializer:bytes"`
 	InitiatedL1EventGUID uuid.UUID
 
 	Tx       Transaction `gorm:"embedded"`
@@ -33,7 +32,7 @@ type L1TransactionDeposit struct {
 }
 
 type L2TransactionWithdrawal struct {
-	WithdrawalHash       common.Hash `gorm:"serializer:json;primaryKey"`
+	WithdrawalHash       common.Hash `gorm:"serializer:bytes;primaryKey"`
 	Nonce                U256
 	InitiatedL2EventGUID uuid.UUID
 
@@ -53,9 +52,9 @@ type BridgeTransactionsView interface {
 type BridgeTransactionsDB interface {
 	BridgeTransactionsView
 
-	StoreL1TransactionDeposits([]*L1TransactionDeposit) error
+	StoreL1TransactionDeposits([]L1TransactionDeposit) error
 
-	StoreL2TransactionWithdrawals([]*L2TransactionWithdrawal) error
+	StoreL2TransactionWithdrawals([]L2TransactionWithdrawal) error
 	MarkL2TransactionWithdrawalProvenEvent(common.Hash, uuid.UUID) error
 	MarkL2TransactionWithdrawalFinalizedEvent(common.Hash, uuid.UUID, bool) error
 }
@@ -76,7 +75,7 @@ func newBridgeTransactionsDB(db *gorm.DB) BridgeTransactionsDB {
  * Transactions deposited from L1
  */
 
-func (db *bridgeTransactionsDB) StoreL1TransactionDeposits(deposits []*L1TransactionDeposit) error {
+func (db *bridgeTransactionsDB) StoreL1TransactionDeposits(deposits []L1TransactionDeposit) error {
 	result := db.gorm.Create(&deposits)
 	return result.Error
 }
@@ -98,7 +97,7 @@ func (db *bridgeTransactionsDB) L1TransactionDeposit(sourceHash common.Hash) (*L
  * Transactions withdrawn from L2
  */
 
-func (db *bridgeTransactionsDB) StoreL2TransactionWithdrawals(withdrawals []*L2TransactionWithdrawal) error {
+func (db *bridgeTransactionsDB) StoreL2TransactionWithdrawals(withdrawals []L2TransactionWithdrawal) error {
 	result := db.gorm.Create(&withdrawals)
 	return result.Error
 }

indexer/database/bridge_transfers.go

@@ -19,42 +19,40 @@ var (
  */
 
 type TokenPair struct {
-	LocalTokenAddress  common.Address `gorm:"serializer:json"`
-	RemoteTokenAddress common.Address `gorm:"serializer:json"`
+	LocalTokenAddress  common.Address `gorm:"serializer:bytes"`
+	RemoteTokenAddress common.Address `gorm:"serializer:bytes"`
 }
 
 type BridgeTransfer struct {
-	CrossDomainMessageHash *common.Hash `gorm:"serializer:json"`
+	CrossDomainMessageHash *common.Hash `gorm:"serializer:bytes"`
 
 	Tx        Transaction `gorm:"embedded"`
 	TokenPair TokenPair   `gorm:"embedded"`
 }
 
 type L1BridgeDeposit struct {
-	BridgeTransfer `gorm:"embedded"`
-
-	TransactionSourceHash common.Hash `gorm:"primaryKey;serializer:json"`
+	BridgeTransfer        `gorm:"embedded"`
+	TransactionSourceHash common.Hash `gorm:"primaryKey;serializer:bytes"`
 }
 
 type L1BridgeDepositWithTransactionHashes struct {
 	L1BridgeDeposit L1BridgeDeposit `gorm:"embedded"`
 
-	L1TransactionHash common.Hash `gorm:"serializer:json"`
-	L2TransactionHash common.Hash `gorm:"serializer:json"`
+	L1TransactionHash common.Hash `gorm:"serializer:bytes"`
+	L2TransactionHash common.Hash `gorm:"serializer:bytes"`
 }
 
 type L2BridgeWithdrawal struct {
-	BridgeTransfer `gorm:"embedded"`
-
-	TransactionWithdrawalHash common.Hash `gorm:"primaryKey;serializer:json"`
+	BridgeTransfer            `gorm:"embedded"`
+	TransactionWithdrawalHash common.Hash `gorm:"primaryKey;serializer:bytes"`
 }
 
 type L2BridgeWithdrawalWithTransactionHashes struct {
 	L2BridgeWithdrawal L2BridgeWithdrawal `gorm:"embedded"`
-	L2TransactionHash  common.Hash        `gorm:"serializer:json"`
+	L2TransactionHash  common.Hash        `gorm:"serializer:bytes"`
 
-	ProvenL1TransactionHash    common.Hash `gorm:"serializer:json"`
-	FinalizedL1TransactionHash common.Hash `gorm:"serializer:json"`
+	ProvenL1TransactionHash    common.Hash `gorm:"serializer:bytes"`
+	FinalizedL1TransactionHash common.Hash `gorm:"serializer:bytes"`
 }
 
 type BridgeTransfersView interface {
@@ -70,8 +68,8 @@ type BridgeTransfersView interface {
 type BridgeTransfersDB interface {
 	BridgeTransfersView
 
-	StoreL1BridgeDeposits([]*L1BridgeDeposit) error
-	StoreL2BridgeWithdrawals([]*L2BridgeWithdrawal) error
+	StoreL1BridgeDeposits([]L1BridgeDeposit) error
+	StoreL2BridgeWithdrawals([]L2BridgeWithdrawal) error
 }
 
 /**
@@ -90,7 +88,7 @@ func newBridgeTransfersDB(db *gorm.DB) BridgeTransfersDB {
  * Tokens Bridged (Deposited) from L1
  */
 
-func (db *bridgeTransfersDB) StoreL1BridgeDeposits(deposits []*L1BridgeDeposit) error {
+func (db *bridgeTransfersDB) StoreL1BridgeDeposits(deposits []L1BridgeDeposit) error {
 	result := db.gorm.Create(&deposits)
 	return result.Error
 }
@@ -124,7 +122,7 @@ func (db *bridgeTransfersDB) L1BridgeDepositWithFilter(filter BridgeTransfer) (*
 }
 
 type L1BridgeDepositsResponse struct {
-	Deposits    []*L1BridgeDepositWithTransactionHashes
+	Deposits    []L1BridgeDepositWithTransactionHashes
 	Cursor      string
 	HasNextPage bool
 }
@@ -152,7 +150,7 @@ l1_transaction_deposits.l2_transaction_hash`)
 
 	filteredQuery := depositsQuery.Where(&Transaction{FromAddress: address}).Order("l1_bridge_deposits.transaction_source_hash DESC").Limit(limit + 1)
 
-	deposits := []*L1BridgeDepositWithTransactionHashes{}
+	deposits := []L1BridgeDepositWithTransactionHashes{}
 	result := filteredQuery.Scan(&deposits)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
@@ -185,7 +183,7 @@ l1_transaction_deposits.l2_transaction_hash`)
  * Tokens Bridged (Withdrawn) from L2
  */
 
-func (db *bridgeTransfersDB) StoreL2BridgeWithdrawals(withdrawals []*L2BridgeWithdrawal) error {
+func (db *bridgeTransfersDB) StoreL2BridgeWithdrawals(withdrawals []L2BridgeWithdrawal) error {
 	result := db.gorm.Create(&withdrawals)
 	return result.Error
 }
@@ -219,7 +217,7 @@ func (db *bridgeTransfersDB) L2BridgeWithdrawalWithFilter(filter BridgeTransfer)
 }
 
 type L2BridgeWithdrawalsResponse struct {
-	Withdrawals []*L2BridgeWithdrawalWithTransactionHashes
+	Withdrawals []L2BridgeWithdrawalWithTransactionHashes
 	Cursor      string
 	HasNextPage bool
 }
@@ -249,7 +247,7 @@ finalized_l1_contract_events.transaction_hash AS finalized_l1_transaction_hash`)
 
 	filteredQuery := withdrawalsQuery.Where(&Transaction{FromAddress: address}).Order("l2_bridge_withdrawals.timestamp DESC").Limit(limit + 1)
 
-	withdrawals := []*L2BridgeWithdrawalWithTransactionHashes{}
+	withdrawals := []L2BridgeWithdrawalWithTransactionHashes{}
 	result := filteredQuery.Scan(&withdrawals)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {

indexer/database/contract_events.go

@@ -2,6 +2,7 @@ package database
 
 import (
 	"errors"
+	"fmt"
 	"math/big"
 
 	"gorm.io/gorm"
@@ -20,12 +21,12 @@ type ContractEvent struct {
 	GUID uuid.UUID `gorm:"primaryKey"`
 
 	// Some useful derived fields
-	BlockHash       common.Hash    `gorm:"serializer:json"`
-	ContractAddress common.Address `gorm:"serializer:json"`
-	TransactionHash common.Hash    `gorm:"serializer:json"`
+	BlockHash       common.Hash    `gorm:"serializer:bytes"`
+	ContractAddress common.Address `gorm:"serializer:bytes"`
+	TransactionHash common.Hash    `gorm:"serializer:bytes"`
 	LogIndex        uint64
 
-	EventSignature common.Hash `gorm:"serializer:json"`
+	EventSignature common.Hash `gorm:"serializer:bytes"`
 	Timestamp      uint64
 
 	// NOTE: NOT ALL THE DERIVED FIELDS ON `types.Log` ARE
@@ -74,19 +75,23 @@ type L2ContractEvent struct {
 
 type ContractEventsView interface {
 	L1ContractEvent(uuid.UUID) (*L1ContractEvent, error)
-	L1ContractEventByTxLogIndex(common.Hash, uint64) (*L1ContractEvent, error)
+	L1ContractEventWithFilter(ContractEvent) (*L1ContractEvent, error)
 	L1ContractEventsWithFilter(ContractEvent, *big.Int, *big.Int) ([]L1ContractEvent, error)
+	L1LatestContractEventWithFilter(ContractEvent) (*L1ContractEvent, error)
 
 	L2ContractEvent(uuid.UUID) (*L2ContractEvent, error)
-	L2ContractEventByTxLogIndex(common.Hash, uint64) (*L2ContractEvent, error)
+	L2ContractEventWithFilter(ContractEvent) (*L2ContractEvent, error)
 	L2ContractEventsWithFilter(ContractEvent, *big.Int, *big.Int) ([]L2ContractEvent, error)
+	L2LatestContractEventWithFilter(ContractEvent) (*L2ContractEvent, error)
+
+	ContractEventsWithFilter(ContractEvent, string, *big.Int, *big.Int) ([]ContractEvent, error)
 }
 
 type ContractEventsDB interface {
 	ContractEventsView
 
-	StoreL1ContractEvents([]*L1ContractEvent) error
-	StoreL2ContractEvents([]*L2ContractEvent) error
+	StoreL1ContractEvents([]L1ContractEvent) error
+	StoreL2ContractEvents([]L2ContractEvent) error
 }
 
 /**
@@ -103,33 +108,22 @@ func newContractEventsDB(db *gorm.DB) ContractEventsDB {
 
 // L1
 
-func (db *contractEventsDB) StoreL1ContractEvents(events []*L1ContractEvent) error {
+func (db *contractEventsDB) StoreL1ContractEvents(events []L1ContractEvent) error {
 	result := db.gorm.Create(&events)
 	return result.Error
 }
 
 func (db *contractEventsDB) L1ContractEvent(uuid uuid.UUID) (*L1ContractEvent, error) {
-	var l1ContractEvent L1ContractEvent
-	result := db.gorm.Where(&ContractEvent{GUID: uuid}).Take(&l1ContractEvent)
-	if result.Error != nil {
-		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
-			return nil, nil
-		}
-
-		return nil, result.Error
-	}
-
-	return &l1ContractEvent, nil
+	return db.L1ContractEventWithFilter(ContractEvent{GUID: uuid})
 }
 
-func (db *contractEventsDB) L1ContractEventByTxLogIndex(txHash common.Hash, logIndex uint64) (*L1ContractEvent, error) {
+func (db *contractEventsDB) L1ContractEventWithFilter(filter ContractEvent) (*L1ContractEvent, error) {
 	var l1ContractEvent L1ContractEvent
-	result := db.gorm.Where(&ContractEvent{TransactionHash: txHash, LogIndex: logIndex}).Take(&l1ContractEvent)
+	result := db.gorm.Where(&filter).Take(&l1ContractEvent)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
@@ -140,6 +134,12 @@ func (db *contractEventsDB) L1ContractEventsWithFilter(filter ContractEvent, fro
 	if fromHeight == nil {
 		fromHeight = big.NewInt(0)
 	}
+	if toHeight == nil {
+		return nil, errors.New("end height unspecified")
+	}
+	if fromHeight.Cmp(toHeight) > 0 {
+		return nil, fmt.Errorf("fromHeight %d is greater than toHeight %d", fromHeight, toHeight)
+	}
 
 	query := db.gorm.Table("l1_contract_events").Where(&filter)
 	query = query.Joins("INNER JOIN l1_block_headers ON l1_contract_events.block_hash = l1_block_headers.hash")
@@ -160,35 +160,37 @@ func (db *contractEventsDB) L1ContractEventsWithFilter(filter ContractEvent, fro
 	return events, nil
 }
 
-// L2
-
-func (db *contractEventsDB) StoreL2ContractEvents(events []*L2ContractEvent) error {
-	result := db.gorm.Create(&events)
-	return result.Error
-}
-
-func (db *contractEventsDB) L2ContractEvent(uuid uuid.UUID) (*L2ContractEvent, error) {
-	var l2ContractEvent L2ContractEvent
-	result := db.gorm.Where(&ContractEvent{GUID: uuid}).Take(&l2ContractEvent)
+func (db *contractEventsDB) L1LatestContractEventWithFilter(filter ContractEvent) (*L1ContractEvent, error) {
+	var l1ContractEvent L1ContractEvent
+	result := db.gorm.Where(&filter).Order("timestamp DESC").Take(&l1ContractEvent)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
-	return &l2ContractEvent, nil
+	return &l1ContractEvent, nil
 }
 
-func (db *contractEventsDB) L2ContractEventByTxLogIndex(txHash common.Hash, logIndex uint64) (*L2ContractEvent, error) {
+// L2
+
+func (db *contractEventsDB) StoreL2ContractEvents(events []L2ContractEvent) error {
+	result := db.gorm.Create(&events)
+	return result.Error
+}
+
+func (db *contractEventsDB) L2ContractEvent(uuid uuid.UUID) (*L2ContractEvent, error) {
+	return db.L2ContractEventWithFilter(ContractEvent{GUID: uuid})
+}
+
+func (db *contractEventsDB) L2ContractEventWithFilter(filter ContractEvent) (*L2ContractEvent, error) {
 	var l2ContractEvent L2ContractEvent
-	result := db.gorm.Where(&ContractEvent{TransactionHash: txHash, LogIndex: logIndex}).Take(&l2ContractEvent)
+	result := db.gorm.Where(&filter).Take(&l2ContractEvent)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
-
 		return nil, result.Error
 	}
 
@@ -199,6 +201,12 @@ func (db *contractEventsDB) L2ContractEventsWithFilter(filter ContractEvent, fro
 	if fromHeight == nil {
 		fromHeight = big.NewInt(0)
 	}
+	if toHeight == nil {
+		return nil, errors.New("end height unspecified")
+	}
+	if fromHeight.Cmp(toHeight) > 0 {
+		return nil, fmt.Errorf("fromHeight %d is greater than toHeight %d", fromHeight, toHeight)
+	}
 
 	query := db.gorm.Table("l2_contract_events").Where(&filter)
 	query = query.Joins("INNER JOIN l2_block_headers ON l2_contract_events.block_hash = l2_block_headers.hash")
@@ -218,3 +226,46 @@ func (db *contractEventsDB) L2ContractEventsWithFilter(filter ContractEvent, fro
 
 	return events, nil
 }
+
+func (db *contractEventsDB) L2LatestContractEventWithFilter(filter ContractEvent) (*L2ContractEvent, error) {
+	var l2ContractEvent L2ContractEvent
+	result := db.gorm.Where(&filter).Order("timestamp DESC").Take(&l2ContractEvent)
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+
+	return &l2ContractEvent, nil
+}
+
+// Auxiliary methods for both L1 and L2
+
+// ContractEventsWithFilter will retrieve contract events within the specified range according to the `chainSelector`.
+func (db *contractEventsDB) ContractEventsWithFilter(filter ContractEvent, chainSelector string, fromHeight, toHeight *big.Int) ([]ContractEvent, error) {
+	switch chainSelector {
+	case "l1":
+		l1Events, err := db.L1ContractEventsWithFilter(filter, fromHeight, toHeight)
+		if err != nil {
+			return nil, err
+		}
+		events := make([]ContractEvent, len(l1Events))
+		for i := range l1Events {
+			events[i] = l1Events[i].ContractEvent
+		}
+		return events, nil
+	case "l2":
+		l2Events, err := db.L2ContractEventsWithFilter(filter, fromHeight, toHeight)
+		if err != nil {
+			return nil, err
+		}
+		events := make([]ContractEvent, len(l2Events))
+		for i := range l2Events {
+			events[i] = l2Events[i].ContractEvent
+		}
+		return events, nil
+	default:
+		return nil, errors.New("expected 'l1' or 'l2' for chain selection")
+	}
+}

indexer/database/db.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 
 	"github.com/ethereum-optimism/optimism/indexer/config"
+	_ "github.com/ethereum-optimism/optimism/indexer/database/serializers"
+
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"

indexer/database/serializers/bytes.go

+package serializers
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"gorm.io/gorm/schema"
+)
+
+type BytesSerializer struct{}
+type BytesInterface interface{ Bytes() []byte }
+type SetBytesInterface interface{ SetBytes([]byte) }
+
+func init() {
+	schema.RegisterSerializer("bytes", BytesSerializer{})
+}
+
+func (BytesSerializer) Scan(ctx context.Context, field *schema.Field, dst reflect.Value, dbValue interface{}) error {
+	if dbValue == nil {
+		return nil
+	}
+
+	hexStr, ok := dbValue.(string)
+	if !ok {
+		return fmt.Errorf("expected hex string as the database value: %T", dbValue)
+	}
+
+	b, err := hexutil.Decode(hexStr)
+	if err != nil {
+		return fmt.Errorf("failed to decode database value: %w", err)
+	}
+
+	fieldValue := reflect.New(field.FieldType)
+	fieldInterface := fieldValue.Interface()
+
+	// Detect if we're deserializing into a pointer. If so, we'll need to
+	// also allocate memory to where the allocated pointer should point to
+	if field.FieldType.Kind() == reflect.Pointer {
+		nestedField := fieldValue.Elem()
+		if nestedField.Elem().Kind() == reflect.Pointer {
+			return fmt.Errorf("double pointers are the max depth supported: %T", fieldValue)
+		}
+
+		// We'll want to call `SetBytes` on the pointer to
+		// the allocated memory and not the double pointer
+		nestedField.Set(reflect.New(field.FieldType.Elem()))
+		fieldInterface = nestedField.Interface()
+	}
+
+	fieldSetBytes, ok := fieldInterface.(SetBytesInterface)
+	if !ok {
+		return fmt.Errorf("field does not satisfy the `SetBytes([]byte)` interface: %T", fieldInterface)
+	}
+
+	fieldSetBytes.SetBytes(b)
+	field.ReflectValueOf(ctx, dst).Set(fieldValue.Elem())
+	return nil
+}
+
+func (BytesSerializer) Value(ctx context.Context, field *schema.Field, dst reflect.Value, fieldValue interface{}) (interface{}, error) {
+	if fieldValue == nil || (field.FieldType.Kind() == reflect.Pointer && reflect.ValueOf(fieldValue).IsNil()) {
+		return nil, nil
+	}
+
+	fieldBytes, ok := fieldValue.(BytesInterface)
+	if !ok {
+		return nil, fmt.Errorf("field does not satisfy the `Bytes() []byte` interface")
+	}
+
+	hexStr := hexutil.Encode(fieldBytes.Bytes())
+	return hexStr, nil
+}

indexer/database/rlp_serializer.go → indexer/database/serializers/rlp.go

-package database
+package serializers
 
 import (
 	"context"
@@ -13,38 +13,28 @@ import (
 
 type RLPSerializer struct{}
 
-type RLPInterface interface {
-	rlp.Encoder
-	rlp.Decoder
-}
-
 func init() {
 	schema.RegisterSerializer("rlp", RLPSerializer{})
 }
 
 func (RLPSerializer) Scan(ctx context.Context, field *schema.Field, dst reflect.Value, dbValue interface{}) error {
-	fieldValue := reflect.New(field.FieldType)
-	if dbValue != nil {
-		var bytes []byte
-		switch v := dbValue.(type) {
-		case []byte:
-			bytes = v
-		case string:
-			b, err := hexutil.Decode(v)
-			if err != nil {
-				return err
-			}
-			bytes = b
-		default:
-			return fmt.Errorf("unrecognized RLP bytes: %#v", dbValue)
-		}
+	if dbValue == nil {
+		return nil
+	}
+
+	hexStr, ok := dbValue.(string)
+	if !ok {
+		return fmt.Errorf("expected hex string as the database value: %T", dbValue)
+	}
 
-		if len(bytes) > 0 {
-			err := rlp.DecodeBytes(bytes, fieldValue.Interface())
-			if err != nil {
-				return err
-			}
-		}
+	b, err := hexutil.Decode(hexStr)
+	if err != nil {
+		return fmt.Errorf("failed to decode database value: %w", err)
+	}
+
+	fieldValue := reflect.New(field.FieldType)
+	if err := rlp.DecodeBytes(b, fieldValue.Interface()); err != nil {
+		return fmt.Errorf("failed to decode rlp bytes: %w", err)
 	}
 
 	field.ReflectValueOf(ctx, dst).Set(fieldValue.Elem())
@@ -52,18 +42,15 @@ func (RLPSerializer) Scan(ctx context.Context, field *schema.Field, dst reflect.
 }
 
 func (RLPSerializer) Value(ctx context.Context, field *schema.Field, dst reflect.Value, fieldValue interface{}) (interface{}, error) {
-	// Even though rlp.Encode takes an interface and will error out if the passed interface does not
-	// satisfy the interface, we check here since we also want to make sure this type satisfies the
-	// rlp.Decoder interface as well
-	i := reflect.TypeOf(new(RLPInterface)).Elem()
-	if !reflect.TypeOf(fieldValue).Implements(i) {
-		return nil, fmt.Errorf("%T does not satisfy RLP Encoder & Decoder interface", fieldValue)
+	if fieldValue == nil || (field.FieldType.Kind() == reflect.Pointer && reflect.ValueOf(fieldValue).IsNil()) {
+		return nil, nil
 	}
 
 	rlpBytes, err := rlp.EncodeToBytes(fieldValue)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to encode rlp bytes: %w", err)
 	}
 
-	return hexutil.Bytes(rlpBytes).MarshalText()
+	hexStr := hexutil.Encode(rlpBytes)
+	return hexStr, nil
 }

indexer/database/types.go

@@ -93,3 +93,12 @@ func (h *RLPHeader) Header() *types.Header {
 func (h *RLPHeader) Hash() common.Hash {
 	return h.Header().Hash()
 }
+
+type Bytes []byte
+
+func (b Bytes) Bytes() []byte {
+	return b[:]
+}
+func (b *Bytes) SetBytes(bytes []byte) {
+	*b = bytes
+}

indexer/docker-compose.yml

@@ -15,26 +15,19 @@ services:
       - "5434:5432"
     volumes:
       - postgres_data:/data/postgres
+      - ./migrations:/docker-entrypoint-initdb.d/
 
   indexer:
     build:
       context: ..
-      dockerfile: indexer/Dockerfile.refresh
-    command: ["indexer-refresh", "processor"]
-    # healthcheck:
-    # Add healthcheck once figure out good way how
-    # maybe after we add metrics?
-    ports:
-      - 8080:8080
+      dockerfile: indexer/Dockerfile
+    command: ["indexer", "index"]
     environment:
-      - INDEXER_DB_PORT=5432
-      - INDEXER_DB_USER=db_username
-      - INDEXER_DB_PASSWORD=db_password
-      - INDEXER_DB_NAME=db_name
-      - INDEXER_DB_HOST=postgres
-      - INDEXER_CONFIG=/configs/indexer.toml
+      - INDEXER_RPC_URL_L1=$INDEXER_RPC_URL_L1
+      - INDEXER_RPC_URL_L2=$INDEXER_RPC_URL_L2
+      - INDEXER_CONFIG=/indexer/indexer.toml
     volumes:
-      - ./indexer.toml:/configs/indexer.toml
+      - ./indexer.toml:/indexer/indexer.toml
     depends_on:
       postgres:
         condition: service_healthy
@@ -43,27 +36,17 @@ services:
     build:
       context: ..
       dockerfile: indexer/Dockerfile
+    command: ["indexer", "api"]
     healthcheck:
       test: wget localhost:8080/healthz -q -O - > /dev/null 2>&1
     environment:
       # Note that you must index goerli with INDEXER_BEDROCK=false first, then
       # reindex with INDEXER_BEDROCK=true or seed the database
-      - INDEXER_BEDROCK=${INDEXER_BEDROCK_GOERLI:-true}
-      - INDEXER_BUILD_ENV=${INDEXER_BUILD_ENV:-development}
-      - INDEXER_DB_PORT=${INDEXER_DB_PORT:-5432}
-      - INDEXER_DB_USER=${INDEXER_DB_USER:-db_username}
-      - INDEXER_DB_PASSWORD=${INDEXER_DB_PASSWORD:-db_password}
-      - INDEXER_DB_NAME=${INDEXER_DB_NAME:-db_name}
-      - INDEXER_DB_HOST=${INDEXER_DB_HOST:-postgres}
-      - INDEXER_CHAIN_ID=${INDEXER_CHAIN_ID:-5}
-      - INDEXER_L1_ETH_RPC=$INDEXER_L1_ETH_RPC
-      - INDEXER_L2_ETH_RPC=$INDEXER_L2_ETH_RPC
-      - INDEXER_REST_HOSTNAME=0.0.0.0
-      - INDEXER_REST_PORT=8080
-      - INDEXER_BEDROCK_L1_STANDARD_BRIDGE=0
-      - INDEXER_BEDROCK_L1_STANDARD_BRIDGE=${INDEXER_BEDROCK_L1_STANDARD_BRIDGE:-0x636Af16bf2f682dD3109e60102b8E1A089FedAa8}
-      - INDEXER_BEDROCK_OPTIMISM_PORTAL=${INDEXER_BEDROCK_OPTIMISM_PORTAL:-0xB7040fd32359688346A3D1395a42114cf8E3b9b2}
-      - INDEXER_L1_ADDRESS_MANAGER_ADDRESS=${INDEXER_L1_ADDRESS_MANAGER_ADDRESS:-0xdE1FCfB0851916CA5101820A69b13a4E276bd81F}
+      - INDEXER_RPC_URL_L1=$INDEXER_RPC_URL_L1
+      - INDEXER_RPC_URL_L2=$INDEXER_RPC_URL_L2
+      - INDEXER_CONFIG=/indexer/indexer.toml
+    volumes:
+      - ./indexer.toml:/indexer/indexer.toml
     ports:
       - 8080:8080
     depends_on:
@@ -98,77 +81,6 @@ services:
       postgres:
         condition: service_healthy
 
-  gateway-frontend:
-    command: pnpm nx start @gateway/frontend --host 0.0.0.0 --port 5173
-    # Change tag to `latest` after https://github.com/ethereum-optimism/gateway/pull/2541 merges
-    image: ethereumoptimism/gateway-frontend:latest
-    ports:
-      - 5173:5173
-    healthcheck:
-      test: curl http://0.0.0.0:5173
-    environment:
-      - VITE_GROWTHBOOK=${VITE_GROWTHBOOK:-https://cdn.growthbook.io/api/features/dev_iGoAbSwtGOtEJONeHdVTosV0BD3TvTPttAccGyRxqsk}
-      - VITE_ENABLE_DEVNET=true
-      - VITE_RPC_URL_ETHEREUM_MAINNET=$VITE_RPC_URL_ETHEREUM_MAINNET
-      - VITE_RPC_URL_ETHEREUM_OPTIMISM_MAINNET=$VITE_RPC_URL_OPTIMISM_MAINNET
-      - VITE_RPC_URL_ETHEREUM_GOERLI=$VITE_RPC_URL_ETHEREUM_GOERLI
-      - VITE_RPC_URL_ETHEREUM_OPTIMISM_GOERLI=$VITE_RPC_URL_OPTIMISM_GOERLI
-      - VITE_BACKEND_URL_MAINNET=http://localhost:7421
-      - VITE_BACKEND_URL_GOERLI=http://localhost:7422
-      - VITE_ENABLE_ALL_FEATURES=true
-
-  backend-mainnet:
-    image: ethereumoptimism/gateway-backend:latest
-    environment:
-      # this enables the backend to proxy history requests to the indexer
-      - BRIDGE_INDEXER_URI=http://api
-      - HOST=0.0.0.0
-      - PORT=7300
-      - MIGRATE_APP_DB_USER=${MIGRATE_APP_DB_USER:-postgres}
-      - MIGRATE_APP_DB_PASSWORD=${MIGRATE_APP_DB_PASSWORD:-db_password}
-      - APP_DB_HOST=${APP_DB_HOST:-postgres-app}
-      - APP_DB_USER=${APP_DB_USER:-gateway-backend-mainnet@oplabs-local-web.iam}
-      - APP_DB_NAME=${APP_DB_NAME:-gateway}
-      - APP_DB_PORT=${APP_DB_PORT:-5432}
-      # THis is for the legacy indexer which won't be used but the env variable is still required
-      - INDEXER_DB_HOST=postgres-mainnet
-      # THis is for the legacy indexer which won't be used but the env variable is still required
-      - INDEXER_DB_USER=db_username
-      # THis is for the legacy indexer which won't be used but the env variable is still required
-      - INDEXER_DB_PASS=db_password
-      # THis is for the legacy indexer which won't be used but the env variable is still required
-      - INDEXER_DB_NAME=db_name
-      # THis is for the legacy indexer which won't be used but the env variable is still required
-      - INDEXER_DB_PORT=5432
-      # THis is for the legacy indexer which won't be used but the env variable is still required
-      - DATABASE_URL=postgres://db_username:db_password@postgres-mainnet:5432/db_name
-      - JSON_RPC_URLS_L1=$JSON_RPC_URLS_L1_MAINNET
-      - JSON_RPC_URLS_L2=$JSON_RPC_URLS_L2_MAINNET
-      - JSON_RPC_URLS_L2_GOERLI=$JSON_RPC_URLS_L2_GOERLI
-      # anvil[0] privater key as placeholder
-      - FAUCET_AUTH_ADMIN_WALLET_PRIVATE_KEY=${$FAUCET_AUTH_ADMIN_WALLET_PRIVATE_KEY:-0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80}
-      - IRON_SESSION_SECRET=${IRON_SESSION_SECRET:-UNKNOWN_IRON_SESSION_PASSWORD_32}
-      - CHAIN_ID_L1=1
-      - CHAIN_ID_L2=10
-      - FLEEK_BUCKET_ADDRESS=34a609661-6774-441f-9fdb-453fdbb89931-bucket
-      - FLEEK_API_SECRET=$FLEEK_API_SECRET
-      - FLEEK_API_KEY=$FLEEK_API_KEY
-      - MOCK_MERKLE_PROOF=true
-      - LOOP_INTERVAL_MINUTES=.1
-      - GITHUB_CLIENT_ID=$GITHUB_CLIENT_ID
-      - GITHUB_SECRET=$GITHUB_SECRET
-      - MAINNET_BEDROCK=$MAINNET_BEDROCK
-      - TRM_API_KEY=$TRM_API_KEY
-      - GOOGLE_CLOUD_STORAGE_BUCKET_NAME=oplabs-dev-web-content
-      # Recommened to uncomment for local dev unless you need it
-      #- BYPASS_EVENT_LOG_POLLER_BOOTSTRAP=true
-    ports:
-      - 7421:7300
-    # overrides command in Dockerfile so we can hot reload the server in docker while developing
-    #command: ['pnpm', 'nx', 'run', '@gateway/backend:docker:watch']
-    healthcheck:
-      test: curl http://0.0.0.0:7300/api/v0/healthz
-
   backend-goerli:
     image: ethereumoptimism/gateway-backend:latest
     environment:

indexer/e2e_tests/bridge_messages_e2e_test.go

@@ -32,9 +32,6 @@ func TestE2EBridgeL1CrossDomainMessenger(t *testing.T) {
 	require.NoError(t, err)
 	l1Opts.Value = big.NewInt(params.Ether)
 
-	// Pause the processor to track relayed event
-	testSuite.Indexer.L2Processor.PauseForTest()
-
 	// (1) Send the Message
 	sentMsgTx, err := l1CrossDomainMessenger.SendMessage(l1Opts, aliceAddr, calldata, 100_000)
 	require.NoError(t, err)
@@ -46,7 +43,7 @@ func TestE2EBridgeL1CrossDomainMessenger(t *testing.T) {
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= sentMsgReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -70,17 +67,18 @@ func TestE2EBridgeL1CrossDomainMessenger(t *testing.T) {
 	require.ElementsMatch(t, calldata, sentMessage.Tx.Data)
 
 	// (2) Process RelayedMesssage on inclusion
-	require.Nil(t, sentMessage.RelayedMessageEventGUID)
-	testSuite.Indexer.L2Processor.ResumeForTest()
+	//   - We dont assert that `RelayedMessageEventGUID` is nil prior to inclusion since there isn't a
+	//   a straightforward way of pausing/resuming the processors at the right time. The codepath is the
+	//   same for L2->L1 messages which does check for this so we are still covered
 	transaction, err := testSuite.DB.BridgeTransactions.L1TransactionDeposit(sentMessage.TransactionSourceHash)
 	require.NoError(t, err)
 
 	// wait for processor catchup
-	depositReceipt, err := wait.ForReceiptOK(context.Background(), testSuite.L2Client, transaction.L2TransactionHash)
+	l2DepositReceipt, err := wait.ForReceiptOK(context.Background(), testSuite.L2Client, transaction.L2TransactionHash)
 	require.NoError(t, err)
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
-		return l2Header != nil && l2Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+		l2Header := testSuite.Indexer.BridgeProcessor.LatestL2Header
+		return l2Header != nil && l2Header.Number.Uint64() >= l2DepositReceipt.BlockNumber.Uint64(), nil
 	}))
 
 	sentMessage, err = testSuite.DB.BridgeMessages.L1BridgeMessage(parsedMessage.MessageHash)
@@ -132,7 +130,7 @@ func TestE2EBridgeL2CrossDomainMessenger(t *testing.T) {
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		l2Header := testSuite.Indexer.BridgeProcessor.LatestL2Header
 		return l2Header != nil && l2Header.Number.Uint64() >= sentMsgReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -157,11 +155,11 @@ func TestE2EBridgeL2CrossDomainMessenger(t *testing.T) {
 
 	// (2) Process RelayedMessage on withdrawal finalization
 	require.Nil(t, sentMessage.RelayedMessageEventGUID)
-	_, finalizedReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, sentMsgReceipt)
+	_, finalizedReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.EthInstances["sequencer"], testSuite.OpCfg.Secrets.Alice, sentMsgReceipt)
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= finalizedReceipt.BlockNumber.Uint64(), nil
 	}))
 

indexer/e2e_tests/bridge_transactions_e2e_test.go

@@ -46,12 +46,13 @@ func TestE2EBridgeTransactionsOptimismPortalDeposits(t *testing.T) {
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
 	}))
 
 	deposit, err := testSuite.DB.BridgeTransactions.L1TransactionDeposit(depositInfo.DepositTx.SourceHash)
 	require.NoError(t, err)
+	require.NotNil(t, deposit)
 	require.Equal(t, depositL2TxHash, deposit.L2TransactionHash)
 	require.Equal(t, big.NewInt(100_000), deposit.GasLimit.Int)
 	require.Equal(t, big.NewInt(params.Ether), deposit.Tx.Amount.Int)
@@ -100,7 +101,7 @@ func TestE2EBridgeTransactionsL2ToL1MessagePasserWithdrawal(t *testing.T) {
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		l2Header := testSuite.Indexer.BridgeProcessor.LatestL2Header
 		return l2Header != nil && l2Header.Number.Uint64() >= withdrawReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -111,6 +112,7 @@ func TestE2EBridgeTransactionsL2ToL1MessagePasserWithdrawal(t *testing.T) {
 
 	withdraw, err := testSuite.DB.BridgeTransactions.L2TransactionWithdrawal(withdrawalHash)
 	require.NoError(t, err)
+	require.NotNil(t, withdraw)
 	require.Equal(t, msgPassed.Nonce.Uint64(), withdraw.Nonce.Int.Uint64())
 	require.Equal(t, big.NewInt(100_000), withdraw.GasLimit.Int)
 	require.Equal(t, big.NewInt(params.Ether), withdraw.Tx.Amount.Int)
@@ -127,9 +129,9 @@ func TestE2EBridgeTransactionsL2ToL1MessagePasserWithdrawal(t *testing.T) {
 	require.Nil(t, withdraw.ProvenL1EventGUID)
 	require.Nil(t, withdraw.FinalizedL1EventGUID)
 
-	withdrawParams, proveReceipt := op_e2e.ProveWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
+	withdrawParams, proveReceipt := op_e2e.ProveWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.EthInstances["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= proveReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -147,7 +149,7 @@ func TestE2EBridgeTransactionsL2ToL1MessagePasserWithdrawal(t *testing.T) {
 
 	finalizeReceipt := op_e2e.FinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpCfg.Secrets.Alice, proveReceipt, withdrawParams)
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -187,9 +189,9 @@ func TestE2EBridgeTransactionsL2ToL1MessagePasserFailedWithdrawal(t *testing.T)
 	require.NoError(t, err)
 
 	// Prove&Finalize withdrawal
-	_, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
+	_, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.EthInstances["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
 	}))
 

indexer/e2e_tests/bridge_transfers_e2e_test.go

@@ -43,7 +43,7 @@ func TestE2EBridgeTransfersStandardBridgeETHDeposit(t *testing.T) {
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -73,11 +73,11 @@ func TestE2EBridgeTransfersStandardBridgeETHDeposit(t *testing.T) {
 	require.NotNil(t, deposit.CrossDomainMessageHash)
 
 	// (2) Test Deposit Finalization via CrossDomainMessenger relayed message
-	depositReceipt, err = wait.ForReceiptOK(context.Background(), testSuite.L2Client, types.NewTx(depositInfo.DepositTx).Hash())
+	l2DepositReceipt, err := wait.ForReceiptOK(context.Background(), testSuite.L2Client, types.NewTx(depositInfo.DepositTx).Hash())
 	require.NoError(t, err)
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
-		return l2Header != nil && l2Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+		l2Header := testSuite.Indexer.BridgeProcessor.LatestL2Header
+		return l2Header != nil && l2Header.Number.Uint64() >= l2DepositReceipt.BlockNumber.Uint64(), nil
 	}))
 
 	crossDomainBridgeMessage, err := testSuite.DB.BridgeMessages.L1BridgeMessage(*deposit.CrossDomainMessageHash)
@@ -221,7 +221,7 @@ func TestE2EBridgeTransfersOptimismPortalETHReceive(t *testing.T) {
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= portalDepositReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -242,11 +242,11 @@ func TestE2EBridgeTransfersOptimismPortalETHReceive(t *testing.T) {
 	require.Nil(t, deposit.CrossDomainMessageHash)
 
 	// (2) Test Deposit Finalization
-	depositReceipt, err := wait.ForReceiptOK(context.Background(), testSuite.L2Client, types.NewTx(depositInfo.DepositTx).Hash())
+	l2DepositReceipt, err := wait.ForReceiptOK(context.Background(), testSuite.L2Client, types.NewTx(depositInfo.DepositTx).Hash())
 	require.NoError(t, err)
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
-		return l2Header != nil && l2Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+		l2Header := testSuite.Indexer.BridgeProcessor.LatestL2Header
+		return l2Header != nil && l2Header.Number.Uint64() >= l2DepositReceipt.BlockNumber.Uint64(), nil
 	}))
 
 	// Still nil as the withdrawal did not occur through the standard bridge
@@ -286,7 +286,7 @@ func TestE2EBridgeTransfersStandardBridgeETHWithdrawal(t *testing.T) {
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		l2Header := testSuite.Indexer.BridgeProcessor.LatestL2Header
 		return l2Header != nil && l2Header.Number.Uint64() >= withdrawReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -322,9 +322,9 @@ func TestE2EBridgeTransfersStandardBridgeETHWithdrawal(t *testing.T) {
 	require.Empty(t, aliceWithdrawals.Withdrawals[0].FinalizedL1TransactionHash)
 
 	// wait for processor catchup
-	proveReceipt, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
+	proveReceipt, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.EthInstances["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -370,7 +370,7 @@ func TestE2EBridgeTransfersL2ToL1MessagePasserReceive(t *testing.T) {
 
 	// wait for processor catchup
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		l2Header := testSuite.Indexer.BridgeProcessor.LatestL2Header
 		return l2Header != nil && l2Header.Number.Uint64() >= l2ToL1WithdrawReceipt.BlockNumber.Uint64(), nil
 	}))
 
@@ -400,9 +400,9 @@ func TestE2EBridgeTransfersL2ToL1MessagePasserReceive(t *testing.T) {
 	require.Empty(t, aliceWithdrawals.Withdrawals[0].FinalizedL1TransactionHash)
 
 	// wait for processor catchup
-	proveReceipt, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, l2ToL1WithdrawReceipt)
+	proveReceipt, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.EthInstances["sequencer"], testSuite.OpCfg.Secrets.Alice, l2ToL1WithdrawReceipt)
 	require.NoError(t, wait.For(context.Background(), 500*time.Millisecond, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		l1Header := testSuite.Indexer.BridgeProcessor.LatestL1Header
 		return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
 	}))
 

indexer/e2e_tests/blocks_e2e_test.go → indexer/e2e_tests/etl_e2e_test.go

@@ -6,43 +6,45 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/indexer/node"
+	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/rlp"
 
 	"github.com/stretchr/testify/require"
 )
 
-func TestE2EBlockHeaders(t *testing.T) {
+func TestE2EETL(t *testing.T) {
 	testSuite := createE2ETestSuite(t)
 
 	l2OutputOracle, err := bindings.NewL2OutputOracle(testSuite.OpCfg.L1Deployments.L2OutputOracleProxy, testSuite.L1Client)
 	require.NoError(t, err)
 
-	// wait for at least 10 L2 blocks to be created & posted on L1
+	// wait for at least 10 L2 blocks posted on L1
 	require.NoError(t, wait.For(context.Background(), time.Second, func() (bool, error) {
 		l2Height, err := l2OutputOracle.LatestBlockNumber(&bind.CallOpts{Context: context.Background()})
 		return l2Height != nil && l2Height.Uint64() >= 9, err
 	}))
 
-	// ensure the processors are caught up to this state
+	// ensure we've indexed up to this state
 	l1Height, err := testSuite.L1Client.BlockNumber(context.Background())
 	require.NoError(t, err)
-	require.NoError(t, wait.For(context.Background(), time.Second, func() (bool, error) {
-		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
-		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
-		return (l1Header != nil && l1Header.Number.Uint64() >= l1Height) && (l2Header != nil && l2Header.Number.Uint64() >= 9), nil
+	require.NoError(t, wait.For(context.Background(), 100*time.Millisecond, func() (bool, error) {
+		l1Header, err := testSuite.DB.Blocks.L1LatestBlockHeader()
+		require.NoError(t, err)
+
+		l2Header, err := testSuite.DB.Blocks.L2LatestBlockHeader()
+		require.NoError(t, err)
+
+		return (l1Header != nil && l1Header.Number.Int.Uint64() >= l1Height) && (l2Header != nil && l2Header.Number.Int.Uint64() >= 9), nil
 	}))
 
-	t.Run("indexes L2 blocks", func(t *testing.T) {
-		latestL2Header, err := testSuite.DB.Blocks.LatestL2BlockHeader()
+	t.Run("indexes all L2 blocks", func(t *testing.T) {
+		latestL2Header, err := testSuite.DB.Blocks.L2LatestBlockHeader()
 		require.NoError(t, err)
 		require.NotNil(t, latestL2Header)
 		require.True(t, latestL2Header.Number.Int.Uint64() >= 9)
@@ -50,7 +52,7 @@ func TestE2EBlockHeaders(t *testing.T) {
 		for i := int64(0); i < 10; i++ {
 			height := big.NewInt(i)
 
-			indexedHeader, err := testSuite.DB.Blocks.L2BlockHeader(height)
+			indexedHeader, err := testSuite.DB.Blocks.L2BlockHeaderWithFilter(database.BlockHeader{Number: database.U256{Int: height}})
 			require.NoError(t, err)
 			require.NotNil(t, indexedHeader)
 
@@ -63,59 +65,61 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.Equal(t, header.ParentHash, indexedHeader.ParentHash)
 			require.Equal(t, header.Time, indexedHeader.Timestamp)
 
-			// ensure the right rlp encoding is stored. checking the hashes sufficies
+			// ensure the right rlp encoding is stored. checking the hashes
+			// suffices as it is based on the rlp bytes of the header
 			require.Equal(t, header.Hash(), indexedHeader.RLPHeader.Hash())
 		}
 	})
 
-	t.Run("indexes L2 checkpoints", func(t *testing.T) {
-		latestOutput, err := testSuite.DB.Blocks.LatestCheckpointedOutput()
-		require.NoError(t, err)
-		require.NotNil(t, latestOutput)
-		require.GreaterOrEqual(t, latestOutput.L2BlockNumber.Int.Uint64(), uint64(9))
-
-		l2EthClient, err := node.DialEthClient(testSuite.OpSys.Nodes["sequencer"].HTTPEndpoint())
-		require.NoError(t, err)
-
-		submissionInterval := testSuite.OpCfg.DeployConfig.L2OutputOracleSubmissionInterval
-		numOutputs := latestOutput.L2BlockNumber.Int.Uint64() / submissionInterval
-		for i := int64(0); i < int64(numOutputs); i++ {
-			blockNumber := big.NewInt((i + 1) * int64(submissionInterval))
-
-			output, err := testSuite.DB.Blocks.OutputProposal(big.NewInt(i))
-			require.NoError(t, err)
-			require.NotNil(t, output)
-			require.Equal(t, i, output.L2OutputIndex.Int.Int64())
-			require.Equal(t, blockNumber, output.L2BlockNumber.Int)
-			require.NotEmpty(t, output.L1ContractEventGUID)
-
-			// we may as well check the integrity of the output root
-			l2Block, err := testSuite.L2Client.BlockByNumber(context.Background(), blockNumber)
-			require.NoError(t, err)
-			messagePasserStorageHash, err := l2EthClient.StorageHash(predeploys.L2ToL1MessagePasserAddr, blockNumber)
-			require.NoError(t, err)
-
-			// construct and check output root
-			outputRootPreImage := [128]byte{}                                 // 4 words (first 32 are zero for version 0)
-			copy(outputRootPreImage[32:64], l2Block.Root().Bytes())           // state root
-			copy(outputRootPreImage[64:96], messagePasserStorageHash.Bytes()) // message passer storage root
-			copy(outputRootPreImage[96:128], l2Block.Hash().Bytes())          // block hash
-			require.Equal(t, crypto.Keccak256Hash(outputRootPreImage[:]), output.OutputRoot)
-		}
-	})
-
-	t.Run("indexes L1 logs and associated blocks", func(t *testing.T) {
-		testCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-
+	/*
+		TODO: ADD THIS BACK IN WHEN THESE MARKERS ARE INDEXED
+			t.Run("indexes L2 checkpoints", func(t *testing.T) {
+				latestOutput, err := testSuite.DB.Blocks.LatestCheckpointedOutput()
+				require.NoError(t, err)
+				require.NotNil(t, latestOutput)
+				require.GreaterOrEqual(t, latestOutput.L2BlockNumber.Int.Uint64(), uint64(9))
+
+				l2EthClient, err := node.DialEthClient(testSuite.OpSys.EthInstances["sequencer"].HTTPEndpoint())
+				require.NoError(t, err)
+
+				submissionInterval := testSuite.OpCfg.DeployConfig.L2OutputOracleSubmissionInterval
+				numOutputs := latestOutput.L2BlockNumber.Int.Uint64() / submissionInterval
+				for i := int64(0); i < int64(numOutputs); i++ {
+					blockNumber := big.NewInt((i + 1) * int64(submissionInterval))
+
+					output, err := testSuite.DB.Blocks.OutputProposal(big.NewInt(i))
+					require.NoError(t, err)
+					require.NotNil(t, output)
+					require.Equal(t, i, output.L2OutputIndex.Int.Int64())
+					require.Equal(t, blockNumber, output.L2BlockNumber.Int)
+					require.NotEmpty(t, output.L1ContractEventGUID)
+
+					// we may as well check the integrity of the output root
+					l2Block, err := testSuite.L2Client.BlockByNumber(context.Background(), blockNumber)
+					require.NoError(t, err)
+					messagePasserStorageHash, err := l2EthClient.StorageHash(predeploys.L2ToL1MessagePasserAddr, blockNumber)
+					require.NoError(t, err)
+
+					// construct and check output root
+					outputRootPreImage := [128]byte{}                                 // 4 words (first 32 are zero for version 0)
+					copy(outputRootPreImage[32:64], l2Block.Root().Bytes())           // state root
+					copy(outputRootPreImage[64:96], messagePasserStorageHash.Bytes()) // message passer storage root
+					copy(outputRootPreImage[96:128], l2Block.Hash().Bytes())          // block hash
+					require.Equal(t, crypto.Keccak256Hash(outputRootPreImage[:]), output.OutputRoot)
+				}
+			})
+	*/
+
+	t.Run("indexes L1 blocks with accompanying contract event", func(t *testing.T) {
 		l1Contracts := []common.Address{}
 		testSuite.OpCfg.L1Deployments.ForEach(func(name string, addr common.Address) { l1Contracts = append(l1Contracts, addr) })
 		logFilter := ethereum.FilterQuery{FromBlock: big.NewInt(0), ToBlock: big.NewInt(int64(l1Height)), Addresses: l1Contracts}
-		logs, err := testSuite.L1Client.FilterLogs(testCtx, logFilter) // []types.Log
+		logs, err := testSuite.L1Client.FilterLogs(context.Background(), logFilter) // []types.Log
 		require.NoError(t, err)
 
-		for _, log := range logs {
-			contractEvent, err := testSuite.DB.ContractEvents.L1ContractEventByTxLogIndex(log.TxHash, uint64(log.Index))
+		for i := range logs {
+			log := logs[i]
+			contractEvent, err := testSuite.DB.ContractEvents.L1ContractEventWithFilter(database.ContractEvent{TransactionHash: log.TxHash, LogIndex: uint64(log.Index)})
 			require.NoError(t, err)
 			require.Equal(t, log.Topics[0], contractEvent.EventSignature)
 			require.Equal(t, log.BlockHash, contractEvent.BlockHash)
@@ -131,12 +135,12 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.ElementsMatch(t, logRlp, contractEventRlp)
 
 			// ensure the block is also indexed
-			block, err := testSuite.L1Client.BlockByNumber(testCtx, big.NewInt(int64(log.BlockNumber)))
+			block, err := testSuite.L1Client.BlockByNumber(context.Background(), big.NewInt(int64(log.BlockNumber)))
 			require.NoError(t, err)
-
 			require.Equal(t, block.Time(), contractEvent.Timestamp)
+			require.Equal(t, block.Hash(), contractEvent.BlockHash)
 
-			l1BlockHeader, err := testSuite.DB.Blocks.L1BlockHeader(block.Number())
+			l1BlockHeader, err := testSuite.DB.Blocks.L1BlockHeader(block.Hash())
 			require.NoError(t, err)
 			require.Equal(t, block.Hash(), l1BlockHeader.Hash)
 			require.Equal(t, block.ParentHash(), l1BlockHeader.ParentHash)

indexer/e2e_tests/setup.go

@@ -49,7 +49,8 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 
 	// Rollup System Configuration and Start
 	opCfg := op_e2e.DefaultSystemConfig(t)
-	opSys, err := opCfg.Start()
+	opCfg.DeployConfig.FinalizationPeriodSeconds = 2
+	opSys, err := opCfg.Start(t)
 	require.NoError(t, err)
 
 	// E2E tests can run on the order of magnitude of minutes. Once
@@ -66,28 +67,22 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 			User: dbUser,
 		},
 		RPCs: config.RPCsConfig{
-			L1RPC: opSys.Nodes["l1"].HTTPEndpoint(),
-			L2RPC: opSys.Nodes["sequencer"].HTTPEndpoint(),
+			L1RPC: opSys.EthInstances["l1"].HTTPEndpoint(),
+			L2RPC: opSys.EthInstances["sequencer"].HTTPEndpoint(),
 		},
 		Chain: config.ChainConfig{
 			L1Contracts: config.L1Contracts{
-				OptimismPortal:         opCfg.L1Deployments.OptimismPortalProxy,
-				L2OutputOracle:         opCfg.L1Deployments.L2OutputOracleProxy,
-				L1CrossDomainMessenger: opCfg.L1Deployments.L1CrossDomainMessengerProxy,
-				L1StandardBridge:       opCfg.L1Deployments.L1StandardBridgeProxy,
-				L1ERC721Bridge:         opCfg.L1Deployments.L1ERC721BridgeProxy,
+				OptimismPortalProxy:         opCfg.L1Deployments.OptimismPortalProxy,
+				L2OutputOracleProxy:         opCfg.L1Deployments.L2OutputOracleProxy,
+				L1CrossDomainMessengerProxy: opCfg.L1Deployments.L1CrossDomainMessengerProxy,
+				L1StandardBridgeProxy:       opCfg.L1Deployments.L1StandardBridgeProxy,
 			},
 		},
 	}
 
 	db, err := database.NewDB(indexerCfg.DB)
 	require.NoError(t, err)
-	indexer, err := indexer.NewIndexer(
-		indexerCfg.Chain,
-		indexerCfg.RPCs,
-		db,
-		logger,
-	)
+	indexer, err := indexer.NewIndexer(logger, indexerCfg.Chain, indexerCfg.RPCs, db)
 	require.NoError(t, err)
 
 	indexerStoppedCh := make(chan interface{}, 1)

indexer/e2e_tests/utils/cross_domain_messages.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"math/big"
 
-	"github.com/ethereum-optimism/optimism/indexer/processor"
+	"github.com/ethereum-optimism/optimism/indexer/processors/contracts"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -57,5 +57,5 @@ func CrossDomainMessengerSentMessageHash(sentMessage *bindings.CrossDomainMessen
 		return common.Hash{}, err
 	}
 
-	return processor.CrossDomainMessageHash(abi, sentMessage, value)
+	return contracts.CrossDomainMessageHash(abi, sentMessage, value)
 }

indexer/etl/etl.go

+package etl
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/indexer/node"
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+const (
+	defaultLoopInterval     = 5 * time.Second
+	defaultHeaderBufferSize = 500
+)
+
+type ETL struct {
+	log log.Logger
+
+	headerTraversal *node.HeaderTraversal
+	ethClient       *ethclient.Client
+	contracts       []common.Address
+
+	etlBatches chan ETLBatch
+}
+
+type ETLBatch struct {
+	Logger log.Logger
+
+	Headers   []types.Header
+	HeaderMap map[common.Hash]*types.Header
+
+	Logs           []types.Log
+	HeadersWithLog map[common.Hash]bool
+}
+
+func (etl *ETL) Start(ctx context.Context) error {
+	done := ctx.Done()
+	pollTicker := time.NewTicker(defaultLoopInterval)
+	defer pollTicker.Stop()
+
+	etl.log.Info("starting etl...")
+	var headers []types.Header
+	for {
+		select {
+		case <-done:
+			etl.log.Info("stopping etl")
+			return nil
+
+		case <-pollTicker.C:
+			if len(headers) == 0 {
+				newHeaders, err := etl.headerTraversal.NextFinalizedHeaders(defaultHeaderBufferSize)
+				if err != nil {
+					etl.log.Error("error querying for headers", "err", err)
+					continue
+				}
+				if len(newHeaders) == 0 {
+					// Logged as an error since this loop should be operating at a longer interval than the provider
+					etl.log.Error("no new headers. processor unexpectedly at head...")
+					continue
+				}
+
+				headers = newHeaders
+			} else {
+				etl.log.Info("retrying previous batch")
+			}
+
+			firstHeader := headers[0]
+			lastHeader := headers[len(headers)-1]
+			batchLog := etl.log.New("batch_start_block_number", firstHeader.Number, "batch_end_block_number", lastHeader.Number)
+			batchLog.Info("extracting batch", "size", len(headers))
+
+			headerMap := make(map[common.Hash]*types.Header, len(headers))
+			for i := range headers {
+				headerMap[headers[i].Hash()] = &headers[i]
+			}
+
+			headersWithLog := make(map[common.Hash]bool, len(headers))
+			logFilter := ethereum.FilterQuery{FromBlock: firstHeader.Number, ToBlock: lastHeader.Number, Addresses: etl.contracts}
+			logs, err := etl.ethClient.FilterLogs(context.Background(), logFilter)
+			if err != nil {
+				batchLog.Info("unable to extract logs within batch", "err", err)
+				continue // spin and try again
+			}
+
+			for i := range logs {
+				if _, ok := headerMap[logs[i].BlockHash]; !ok {
+					// NOTE. Definitely an error state if the none of the headers were re-orged out in between
+					// the blocks and logs retreival operations. However, we need to gracefully handle reorgs
+					batchLog.Error("log found with block hash not in the batch", "block_hash", logs[i].BlockHash, "log_index", logs[i].Index)
+					return errors.New("parsed log with a block hash not in the fetched batch")
+				}
+				headersWithLog[logs[i].BlockHash] = true
+			}
+
+			if len(logs) > 0 {
+				batchLog.Info("detected logs", "size", len(logs))
+			}
+
+			// create a new reference such that subsequent changes to `headers` does not affect the reference
+			headersRef := headers
+			batch := ETLBatch{Logger: batchLog, Headers: headersRef, HeaderMap: headerMap, Logs: logs, HeadersWithLog: headersWithLog}
+
+			headers = nil
+			etl.etlBatches <- batch
+		}
+	}
+}

indexer/etl/l1_etl.go

+package etl
+
+import (
+	"context"
+	"errors"
+	"reflect"
+
+	"github.com/ethereum-optimism/optimism/indexer/config"
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/indexer/node"
+	"github.com/ethereum-optimism/optimism/op-service/retry"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type L1ETL struct {
+	ETL
+
+	db *database.DB
+}
+
+func NewL1ETL(log log.Logger, db *database.DB, client node.EthClient, contracts config.L1Contracts) (*L1ETL, error) {
+	log = log.New("etl", "l1")
+
+	contractValue := reflect.ValueOf(contracts)
+	fields := reflect.VisibleFields(reflect.TypeOf(contracts))
+	l1Contracts := make([]common.Address, len(fields))
+	for i, field := range fields {
+		// ruleid: unsafe-reflect-by-name
+		addr, ok := (contractValue.FieldByName(field.Name).Interface()).(common.Address)
+		if !ok {
+			log.Error("non-address found in L1Contracts", "name", field.Name)
+			return nil, errors.New("non-address found in L1Contracts")
+		}
+
+		log.Info("configured contract", "name", field.Name, "addr", addr)
+		l1Contracts[i] = addr
+	}
+
+	latestHeader, err := db.Blocks.L1LatestBlockHeader()
+	if err != nil {
+		return nil, err
+	}
+
+	var fromHeader *types.Header
+	if latestHeader != nil {
+		log.Info("detected last indexed block", "number", latestHeader.Number.Int, "hash", latestHeader.Hash)
+		fromHeader = latestHeader.RLPHeader.Header()
+	} else {
+		log.Info("no indexed state, starting from genesis")
+	}
+
+	etlBatches := make(chan ETLBatch)
+	etl := ETL{
+		log:             log,
+		headerTraversal: node.NewHeaderTraversal(client, fromHeader),
+		ethClient:       client.GethEthClient(),
+		contracts:       l1Contracts,
+		etlBatches:      etlBatches,
+	}
+
+	return &L1ETL{ETL: etl, db: db}, nil
+}
+
+func (l1Etl *L1ETL) Start(ctx context.Context) error {
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- l1Etl.ETL.Start(ctx)
+	}()
+
+	for {
+		select {
+		case err := <-errCh:
+			return err
+
+		// Index incoming batches
+		case batch := <-l1Etl.etlBatches:
+			// Pull out only L1 blocks that have emitted a log ( <= batch.Headers )
+			l1BlockHeaders := make([]database.L1BlockHeader, 0, len(batch.Headers))
+			for i := range batch.Headers {
+				if _, ok := batch.HeadersWithLog[batch.Headers[i].Hash()]; ok {
+					l1BlockHeaders = append(l1BlockHeaders, database.L1BlockHeader{BlockHeader: database.BlockHeaderFromHeader(&batch.Headers[i])})
+				}
+			}
+
+			if len(l1BlockHeaders) == 0 {
+				batch.Logger.Info("no l1 blocks with logs in batch")
+				continue
+			}
+
+			l1ContractEvents := make([]database.L1ContractEvent, len(batch.Logs))
+			for i := range batch.Logs {
+				timestamp := batch.HeaderMap[batch.Logs[i].BlockHash].Time
+				l1ContractEvents[i] = database.L1ContractEvent{ContractEvent: database.ContractEventFromLog(&batch.Logs[i], timestamp)}
+			}
+
+			// Continually try to persist this batch. If it fails after 10 attempts, we simply error out
+			retryStrategy := &retry.ExponentialStrategy{Min: 1000, Max: 20_000, MaxJitter: 250}
+			_, err := retry.Do[interface{}](ctx, 10, retryStrategy, func() (interface{}, error) {
+				err := l1Etl.db.Transaction(func(tx *database.DB) error {
+					if err := tx.Blocks.StoreL1BlockHeaders(l1BlockHeaders); err != nil {
+						return err
+					}
+
+					// we must have logs if we have l1 blocks
+					if err := tx.ContractEvents.StoreL1ContractEvents(l1ContractEvents); err != nil {
+						return err
+					}
+					return nil
+				})
+
+				if err != nil {
+					batch.Logger.Error("unable to persist batch", "err", err)
+					return nil, err
+				}
+
+				// a-ok! Can merge with the above block but being explicit
+				return nil, nil
+			})
+
+			if err != nil {
+				return err
+			}
+
+			batch.Logger.Info("indexed batch")
+		}
+	}
+}

indexer/etl/l2_etl.go

+package etl
+
+import (
+	"context"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/indexer/node"
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum-optimism/optimism/op-service/retry"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type L2ETL struct {
+	ETL
+
+	db *database.DB
+}
+
+func NewL2ETL(log log.Logger, db *database.DB, client node.EthClient) (*L2ETL, error) {
+	log = log.New("etl", "l2")
+
+	// allow predeploys to be overridable
+	l2Contracts := []common.Address{}
+	for name, addr := range predeploys.Predeploys {
+		log.Info("configured contract", "name", name, "addr", addr)
+		l2Contracts = append(l2Contracts, *addr)
+	}
+
+	latestHeader, err := db.Blocks.L2LatestBlockHeader()
+	if err != nil {
+		return nil, err
+	}
+
+	var fromHeader *types.Header
+	if latestHeader != nil {
+		log.Info("detected last indexed block", "number", latestHeader.Number.Int, "hash", latestHeader.Hash)
+		fromHeader = latestHeader.RLPHeader.Header()
+	} else {
+		log.Info("no indexed state, starting from genesis")
+	}
+
+	etlBatches := make(chan ETLBatch)
+	etl := ETL{
+		log:             log,
+		headerTraversal: node.NewHeaderTraversal(client, fromHeader),
+		ethClient:       client.GethEthClient(),
+		contracts:       l2Contracts,
+		etlBatches:      etlBatches,
+	}
+
+	return &L2ETL{ETL: etl, db: db}, nil
+}
+
+func (l2Etl *L2ETL) Start(ctx context.Context) error {
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- l2Etl.ETL.Start(ctx)
+	}()
+
+	for {
+		select {
+		case err := <-errCh:
+			return err
+
+		// Index incoming batches
+		case batch := <-l2Etl.etlBatches:
+			// We're indexing every L2 block.
+			l2BlockHeaders := make([]database.L2BlockHeader, len(batch.Headers))
+			for i := range batch.Headers {
+				l2BlockHeaders[i] = database.L2BlockHeader{BlockHeader: database.BlockHeaderFromHeader(&batch.Headers[i])}
+			}
+
+			l2ContractEvents := make([]database.L2ContractEvent, len(batch.Logs))
+			for i := range batch.Logs {
+				timestamp := batch.HeaderMap[batch.Logs[i].BlockHash].Time
+				l2ContractEvents[i] = database.L2ContractEvent{ContractEvent: database.ContractEventFromLog(&batch.Logs[i], timestamp)}
+			}
+
+			// Continually try to persist this batch. If it fails after 5 attempts, we simply error out
+			retryStrategy := &retry.ExponentialStrategy{Min: 1000, Max: 20_000, MaxJitter: 250}
+			_, err := retry.Do[interface{}](ctx, 10, retryStrategy, func() (interface{}, error) {
+				err := l2Etl.db.Transaction(func(tx *database.DB) error {
+					if err := tx.Blocks.StoreL2BlockHeaders(l2BlockHeaders); err != nil {
+						return err
+					}
+					if len(l2ContractEvents) > 0 {
+						if err := tx.ContractEvents.StoreL2ContractEvents(l2ContractEvents); err != nil {
+							return err
+						}
+					}
+					return nil
+				})
+
+				if err != nil {
+					batch.Logger.Error("unable to persist batch", "err", err)
+					return nil, err
+				}
+
+				// a-ok! Can merge with the above block but being explicit
+				return nil, nil
+			})
+
+			if err != nil {
+				return err
+			}
+
+			batch.Logger.Info("indexed batch")
+		}
+	}
+}

indexer/indexer.go

@@ -3,14 +3,16 @@ package indexer
 import (
 	"context"
 	"fmt"
+	"runtime/debug"
 	"sync"
 
 	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/ethereum-optimism/optimism/indexer/config"
 	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/indexer/etl"
 	"github.com/ethereum-optimism/optimism/indexer/node"
-	"github.com/ethereum-optimism/optimism/indexer/processor"
+	"github.com/ethereum-optimism/optimism/indexer/processors"
 )
 
 // Indexer contains the necessary resources for
@@ -19,38 +21,47 @@ type Indexer struct {
 	db  *database.DB
 	log log.Logger
 
-	L1Processor *processor.L1Processor
-	L2Processor *processor.L2Processor
+	L1ETL *etl.L1ETL
+	L2ETL *etl.L2ETL
+
+	BridgeProcessor *processors.BridgeProcessor
 }
 
 // NewIndexer initializes an instance of the Indexer
-func NewIndexer(chainConfig config.ChainConfig, rpcsConfig config.RPCsConfig, db *database.DB, logger log.Logger) (*Indexer, error) {
-	l1Contracts := chainConfig.L1Contracts
+func NewIndexer(logger log.Logger, chainConfig config.ChainConfig, rpcsConfig config.RPCsConfig, db *database.DB) (*Indexer, error) {
 	l1EthClient, err := node.DialEthClient(rpcsConfig.L1RPC)
 	if err != nil {
 		return nil, err
 	}
-	l1Processor, err := processor.NewL1Processor(logger, l1EthClient, db, l1Contracts)
+
+	l1Etl, err := etl.NewL1ETL(logger, db, l1EthClient, chainConfig.L1Contracts)
 	if err != nil {
 		return nil, err
 	}
 
-	// L2Processor (predeploys). Although most likely the right setting, make this configurable?
-	l2Contracts := processor.L2ContractPredeploys()
 	l2EthClient, err := node.DialEthClient(rpcsConfig.L2RPC)
 	if err != nil {
 		return nil, err
 	}
-	l2Processor, err := processor.NewL2Processor(logger, l2EthClient, db, l2Contracts)
+
+	// Currently defaults to the predeploys
+	l2Etl, err := etl.NewL2ETL(logger, db, l2EthClient)
+	if err != nil {
+		return nil, err
+	}
+
+	bridgeProcessor, err := processors.NewBridgeProcessor(logger, db, chainConfig)
 	if err != nil {
 		return nil, err
 	}
 
 	indexer := &Indexer{
-		db:          db,
-		log:         logger,
-		L1Processor: l1Processor,
-		L2Processor: l2Processor,
+		db:  db,
+		log: logger,
+
+		L1ETL:           l1Etl,
+		L2ETL:           l2Etl,
+		BridgeProcessor: bridgeProcessor,
 	}
 
 	return indexer, nil
@@ -59,39 +70,41 @@ func NewIndexer(chainConfig config.ChainConfig, rpcsConfig config.RPCsConfig, db
 // Start starts the indexing service on L1 and L2 chains
 func (i *Indexer) Run(ctx context.Context) error {
 	var wg sync.WaitGroup
-	errCh := make(chan error, 1)
+	errCh := make(chan error, 3)
 
 	// If either processor errors out, we stop
-	processorCtx, cancel := context.WithCancel(ctx)
+	subCtx, cancel := context.WithCancel(ctx)
 	run := func(start func(ctx context.Context) error) {
 		wg.Add(1)
 		defer func() {
 			if err := recover(); err != nil {
 				i.log.Error("halting indexer on panic", "err", err)
+				debug.PrintStack()
 				errCh <- fmt.Errorf("panic: %v", err)
 			}
 
+			cancel()
 			wg.Done()
 		}()
 
-		err := start(processorCtx)
+		err := start(subCtx)
 		if err != nil {
 			i.log.Error("halting indexer on error", "err", err)
-			cancel()
 		}
 
-		// Send a value down regardless if we've received an error or halted
-		// via cancellation where err == nil
+		// Send a value down regardless if we've received an error
+		// or halted via cancellation where err == nil
 		errCh <- err
 	}
 
-	// Kick off the processors
-	go run(i.L1Processor.Start)
-	go run(i.L2Processor.Start)
+	// Kick off all the dependent routines
+	go run(i.L1ETL.Start)
+	go run(i.L2ETL.Start)
+	go run(i.BridgeProcessor.Start)
 	err := <-errCh
 
-	// ensure both processors have halted before returning
 	wg.Wait()
+	i.log.Info("indexer stopped")
 	return err
 }
 

indexer/indexer.toml

@@ -9,11 +9,11 @@ l1-rpc = "${INDEXER_RPC_URL_L1}"
 l2-rpc = "${INDEXER_RPC_URL_L2}"
 
 [db]
-host = "127.0.0.1"
+host = "postgres"
 port = 5432
-user = "postgres"
-password = "postgres"
-name = "indexer"
+user = "db_username"
+password = "db_password"
+name = "db_name"
 
 [api]
 host = "127.0.0.1"

indexer/migrations/20230523_create_schema.sql

@@ -191,13 +191,13 @@ CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
     cross_domain_message_hash VARCHAR UNIQUE REFERENCES l1_bridge_messages(message_hash),
 
     -- Deposit information
-	from_address     VARCHAR NOT NULL,
-	to_address       VARCHAR NOT NULL,
-	local_token_address VARCHAR NOT NULL, -- REFERENCES l1_tokens(address), uncomment me in future pr
+	from_address         VARCHAR NOT NULL,
+	to_address           VARCHAR NOT NULL,
+	local_token_address  VARCHAR NOT NULL, -- REFERENCES l1_tokens(address), uncomment me in future pr
 	remote_token_address VARCHAR NOT NULL, -- REFERENCES l2_tokens(address), uncomment me in future pr
-	amount           UINT256 NOT NULL,
-	data             VARCHAR NOT NULL,
-    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
+	amount               UINT256 NOT NULL,
+	data                 VARCHAR NOT NULL,
+    timestamp            INTEGER NOT NULL CHECK (timestamp > 0)
 );
 CREATE TABLE IF NOT EXISTS l2_bridge_withdrawals (
     transaction_withdrawal_hash VARCHAR PRIMARY KEY REFERENCES l2_transaction_withdrawals(withdrawal_hash),
@@ -207,11 +207,11 @@ CREATE TABLE IF NOT EXISTS l2_bridge_withdrawals (
     cross_domain_message_hash VARCHAR UNIQUE REFERENCES l2_bridge_messages(message_hash),
 
     -- Withdrawal information
-	from_address     VARCHAR NOT NULL,
-	to_address       VARCHAR NOT NULL,
-	local_token_address VARCHAR NOT NULL, -- REFERENCES l2_tokens(address), uncomment me in future pr
+	from_address         VARCHAR NOT NULL,
+	to_address           VARCHAR NOT NULL,
+	local_token_address  VARCHAR NOT NULL, -- REFERENCES l2_tokens(address), uncomment me in future pr
 	remote_token_address VARCHAR NOT NULL, -- REFERENCES l1_tokens(address), uncomment me in future pr
-	amount           UINT256 NOT NULL,
-	data             VARCHAR NOT NULL,
-    timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
+	amount               UINT256 NOT NULL,
+	data                 VARCHAR NOT NULL,
+    timestamp            INTEGER NOT NULL CHECK (timestamp > 0)
 );

indexer/node/client.go

@@ -27,12 +27,13 @@ const (
 type EthClient interface {
 	FinalizedBlockHeight() (*big.Int, error)
 
-	BlockHeadersByRange(*big.Int, *big.Int) ([]*types.Header, error)
+	BlockHeadersByRange(*big.Int, *big.Int) ([]types.Header, error)
 	BlockHeaderByHash(common.Hash) (*types.Header, error)
 
 	StorageHash(common.Address, *big.Int) (common.Hash, error)
 
-	RawRpcClient() *rpc.Client
+	GethRpcClient() *rpc.Client
+	GethEthClient() *ethclient.Client
 }
 
 type client struct {
@@ -56,10 +57,14 @@ func NewEthClient(rpcClient *rpc.Client) EthClient {
 	return &client{rpcClient}
 }
 
-func (c *client) RawRpcClient() *rpc.Client {
+func (c *client) GethRpcClient() *rpc.Client {
 	return c.rpcClient
 }
 
+func (c *client) GethEthClient() *ethclient.Client {
+	return ethclient.NewClient(c.GethRpcClient())
+}
+
 // FinalizedBlockHeight retrieves the latest block height in a finalized state
 func (c *client) FinalizedBlockHeight() (*big.Int, error) {
 	ctxwt, cancel := context.WithTimeout(context.Background(), defaultRequestTimeout)
@@ -97,7 +102,7 @@ func (c *client) BlockHeaderByHash(hash common.Hash) (*types.Header, error) {
 // BlockHeadersByRange will retrieve block headers within the specified range -- includsive. No restrictions
 // are placed on the range such as blocks in the "latest", "safe" or "finalized" states. If the specified
 // range is too large, `endHeight > latest`, the resulting list is truncated to the available headers
-func (c *client) BlockHeadersByRange(startHeight, endHeight *big.Int) ([]*types.Header, error) {
+func (c *client) BlockHeadersByRange(startHeight, endHeight *big.Int) ([]types.Header, error) {
 	count := new(big.Int).Sub(endHeight, startHeight).Uint64() + 1
 	batchElems := make([]rpc.BatchElem, count)
 	for i := uint64(0); i < count; i++ {
@@ -121,7 +126,7 @@ func (c *client) BlockHeadersByRange(startHeight, endHeight *big.Int) ([]*types.
 	//  - Ensure integrity that they build on top of each other
 	//  - Truncate out headers that do not exist (endHeight > "latest")
 	size := 0
-	headers := make([]*types.Header, count)
+	headers := make([]types.Header, count)
 	for i, batchElem := range batchElems {
 		if batchElem.Error != nil {
 			return nil, batchElem.Error
@@ -129,17 +134,19 @@ func (c *client) BlockHeadersByRange(startHeight, endHeight *big.Int) ([]*types.
 			break
 		}
 
-		header := batchElem.Result.(*types.Header)
+		header, ok := batchElem.Result.(*types.Header)
+		if !ok {
+			return nil, fmt.Errorf("unable to transform rpc response %v into types.Header", batchElem.Result)
+		}
 		if i > 0 && header.ParentHash != headers[i-1].Hash() {
-			// Warn here that we got a bad (malicious?) response
-			break
+			return nil, fmt.Errorf("queried header %s does not follow parent %s", header.Hash(), headers[i-1].Hash())
 		}
 
-		headers[i] = header
+		headers[i] = *header
 		size = size + 1
 	}
-	headers = headers[:size]
 
+	headers = headers[:size]
 	return headers, nil
 }
 

indexer/node/client_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
@@ -21,9 +22,9 @@ func (m *MockEthClient) FinalizedBlockHeight() (*big.Int, error) {
 	return args.Get(0).(*big.Int), args.Error(1)
 }
 
-func (m *MockEthClient) BlockHeadersByRange(from, to *big.Int) ([]*types.Header, error) {
+func (m *MockEthClient) BlockHeadersByRange(from, to *big.Int) ([]types.Header, error) {
 	args := m.Called(from, to)
-	return args.Get(0).([]*types.Header), args.Error(1)
+	return args.Get(0).([]types.Header), args.Error(1)
 }
 
 func (m *MockEthClient) BlockHeaderByHash(hash common.Hash) (*types.Header, error) {
@@ -36,7 +37,12 @@ func (m *MockEthClient) StorageHash(address common.Address, blockNumber *big.Int
 	return args.Get(0).(common.Hash), args.Error(1)
 }
 
-func (m *MockEthClient) RawRpcClient() *rpc.Client {
+func (m *MockEthClient) GethRpcClient() *rpc.Client {
 	args := m.Called()
 	return args.Get(0).(*rpc.Client)
 }
+
+func (m *MockEthClient) GethEthClient() *ethclient.Client {
+	args := m.Called()
+	return args.Get(0).(*ethclient.Client)
+}

indexer/node/header_traversal.go

@@ -26,7 +26,7 @@ func NewHeaderTraversal(ethClient EthClient, fromHeader *types.Header) *HeaderTr
 
 // NextFinalizedHeaders retrives the next set of headers that have been
 // marked as finalized by the connected client, bounded by the supplied size
-func (f *HeaderTraversal) NextFinalizedHeaders(maxSize uint64) ([]*types.Header, error) {
+func (f *HeaderTraversal) NextFinalizedHeaders(maxSize uint64) ([]types.Header, error) {
 	finalizedBlockHeight, err := f.ethClient.FinalizedBlockHeight()
 	if err != nil {
 		return nil, err
@@ -61,6 +61,6 @@ func (f *HeaderTraversal) NextFinalizedHeaders(maxSize uint64) ([]*types.Header,
 		return nil, ErrHeaderTraversalAndProviderMismatchedState
 	}
 
-	f.lastHeader = headers[numHeaders-1]
+	f.lastHeader = &headers[numHeaders-1]
 	return headers, nil
 }

indexer/node/header_traversal_test.go

@@ -11,22 +11,21 @@ import (
 )
 
 // make a set of headers which chain correctly
-func makeHeaders(numHeaders uint64, prevHeader *types.Header) []*types.Header {
-	headers := make([]*types.Header, numHeaders)
+func makeHeaders(numHeaders uint64, prevHeader *types.Header) []types.Header {
+	headers := make([]types.Header, numHeaders)
 	for i := range headers {
 		if i == 0 {
 			if prevHeader == nil {
 				// genesis
-				headers[i] = &types.Header{Number: big.NewInt(0)}
+				headers[i] = types.Header{Number: big.NewInt(0)}
 			} else {
 				// chain onto the previous header
-				headers[i] = &types.Header{Number: big.NewInt(prevHeader.Number.Int64() + 1)}
+				headers[i] = types.Header{Number: big.NewInt(prevHeader.Number.Int64() + 1)}
 				headers[i].ParentHash = prevHeader.Hash()
 			}
 		} else {
-			prevHeader = headers[i-1]
-			headers[i] = &types.Header{Number: big.NewInt(prevHeader.Number.Int64() + 1)}
-			headers[i].ParentHash = prevHeader.Hash()
+			headers[i] = types.Header{Number: big.NewInt(headers[i-1].Number.Int64() + 1)}
+			headers[i].ParentHash = headers[i-1].Hash()
 		}
 	}
 
@@ -62,7 +61,7 @@ func TestHeaderTraversalNextFinalizedHeadersCursored(t *testing.T) {
 	require.Len(t, headers, 5)
 
 	// blocks [5..9]
-	headers = makeHeaders(5, headers[len(headers)-1])
+	headers = makeHeaders(5, &headers[len(headers)-1])
 	client.On("FinalizedBlockHeight").Return(big.NewInt(9), nil)
 	client.On("BlockHeadersByRange", mock.MatchedBy(bigIntMatcher(5)), mock.MatchedBy(bigIntMatcher(9))).Return(headers, nil)
 	headers, err = headerTraversal.NextFinalizedHeaders(5)
@@ -87,7 +86,7 @@ func TestHeaderTraversalNextFinalizedHeadersMaxSize(t *testing.T) {
 	require.Len(t, headers, 5)
 
 	// clamped by the supplied size. FinalizedHeight == 100
-	headers = makeHeaders(10, headers[len(headers)-1])
+	headers = makeHeaders(10, &headers[len(headers)-1])
 	client.On("BlockHeadersByRange", mock.MatchedBy(bigIntMatcher(5)), mock.MatchedBy(bigIntMatcher(14))).Return(headers, nil)
 	headers, err = headerTraversal.NextFinalizedHeaders(10)
 	require.NoError(t, err)

indexer/processor/cross_domain_messenger.go

-package processor
-
-import (
-	"fmt"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-
-	"github.com/ethereum-optimism/optimism/indexer/database"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-)
-
-var (
-	// Standard ABI types copied from golang ABI tests
-	Uint256Type, _ = abi.NewType("uint256", "", nil)
-	BytesType, _   = abi.NewType("bytes", "", nil)
-	AddressType, _ = abi.NewType("address", "", nil)
-
-	LegacyCrossDomainMessengerRelayMessageMethod = abi.NewMethod(
-		"relayMessage",
-		"relayMessage",
-		abi.Function,
-		"external", // mutability
-		false,      // isConst
-		true,       // payable
-		abi.Arguments{ // inputs
-			{Name: "sender", Type: AddressType},
-			{Name: "target", Type: AddressType},
-			{Name: "data", Type: BytesType},
-			{Name: "nonce", Type: Uint256Type},
-		},
-		abi.Arguments{}, // outputs
-	)
-)
-
-type CrossDomainMessengerSentMessageEvent struct {
-	*bindings.CrossDomainMessengerSentMessage
-
-	Value       *big.Int
-	MessageHash common.Hash
-	Event       *database.ContractEvent
-}
-
-type CrossDomainMessengerRelayedMessageEvent struct {
-	*bindings.CrossDomainMessengerRelayedMessage
-	Event *database.ContractEvent
-}
-
-func CrossDomainMessengerSentMessageEvents(events *ProcessedContractEvents) ([]CrossDomainMessengerSentMessageEvent, error) {
-	crossDomainMessengerABI, err := bindings.CrossDomainMessengerMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	sentMessageEventAbi := crossDomainMessengerABI.Events["SentMessage"]
-	sentMessageEventExtensionAbi := crossDomainMessengerABI.Events["SentMessageExtension1"]
-
-	processedSentMessageEvents := events.eventsBySignature[sentMessageEventAbi.ID]
-	crossDomainMessageEvents := make([]CrossDomainMessengerSentMessageEvent, len(processedSentMessageEvents))
-	for i, sentMessageEvent := range processedSentMessageEvents {
-		log := sentMessageEvent.RLPLog
-
-		var sentMsgData bindings.CrossDomainMessengerSentMessage
-		sentMsgData.Raw = *log
-		err = UnpackLog(&sentMsgData, log, sentMessageEventAbi.Name, crossDomainMessengerABI)
-		if err != nil {
-			return nil, err
-		}
-
-		var sentMsgExtensionData bindings.CrossDomainMessengerSentMessageExtension1
-		extensionLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].RLPLog
-		sentMsgExtensionData.Raw = *extensionLog
-		err = UnpackLog(&sentMsgExtensionData, extensionLog, sentMessageEventExtensionAbi.Name, crossDomainMessengerABI)
-		if err != nil {
-			return nil, err
-		}
-
-		msgHash, err := CrossDomainMessageHash(crossDomainMessengerABI, &sentMsgData, sentMsgExtensionData.Value)
-		if err != nil {
-			return nil, err
-		}
-
-		crossDomainMessageEvents[i] = CrossDomainMessengerSentMessageEvent{
-			CrossDomainMessengerSentMessage: &sentMsgData,
-			Value:                           sentMsgExtensionData.Value,
-			MessageHash:                     msgHash,
-			Event:                           sentMessageEvent,
-		}
-	}
-
-	return crossDomainMessageEvents, nil
-}
-
-func CrossDomainMessengerRelayedMessageEvents(events *ProcessedContractEvents) ([]CrossDomainMessengerRelayedMessageEvent, error) {
-	crossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	relayedMessageEventAbi := crossDomainMessengerABI.Events["RelayedMessage"]
-	processedRelayedMessageEvents := events.eventsBySignature[relayedMessageEventAbi.ID]
-	crossDomainMessageEvents := make([]CrossDomainMessengerRelayedMessageEvent, len(processedRelayedMessageEvents))
-	for i, relayedMessageEvent := range processedRelayedMessageEvents {
-		log := relayedMessageEvent.RLPLog
-
-		var relayedMsgData bindings.CrossDomainMessengerRelayedMessage
-		relayedMsgData.Raw = *log
-		err = UnpackLog(&relayedMsgData, log, relayedMessageEventAbi.Name, crossDomainMessengerABI)
-		if err != nil {
-			return nil, err
-		}
-
-		crossDomainMessageEvents[i] = CrossDomainMessengerRelayedMessageEvent{
-			CrossDomainMessengerRelayedMessage: &relayedMsgData,
-			Event:                              relayedMessageEvent,
-		}
-	}
-
-	return crossDomainMessageEvents, nil
-}
-
-// Replica of `Hashing.sol#hashCrossDomainMessage` solidity implementation
-func CrossDomainMessageHash(abi *abi.ABI, sentMsg *bindings.CrossDomainMessengerSentMessage, value *big.Int) (common.Hash, error) {
-	version, _ := DecodeVersionedNonce(sentMsg.MessageNonce)
-	switch version {
-	case 0:
-		// Legacy Message
-		inputBytes, err := LegacyCrossDomainMessengerRelayMessageMethod.Inputs.Pack(sentMsg.Sender, sentMsg.Target, sentMsg.Message, sentMsg.MessageNonce)
-		if err != nil {
-			return common.Hash{}, err
-		}
-		msgBytes := append(LegacyCrossDomainMessengerRelayMessageMethod.ID, inputBytes...)
-		return crypto.Keccak256Hash(msgBytes), nil
-	case 1:
-		// Current Message
-		msgBytes, err := abi.Pack("relayMessage", sentMsg.MessageNonce, sentMsg.Sender, sentMsg.Target, value, sentMsg.GasLimit, sentMsg.Message)
-		if err != nil {
-			return common.Hash{}, err
-		}
-		return crypto.Keccak256Hash(msgBytes), nil
-	}
-
-	return common.Hash{}, fmt.Errorf("unsupported cross domain messenger version: %d", version)
-}

indexer/processor/encoding.go

-package processor
-
-import (
-	"encoding/binary"
-	"math/big"
-)
-
-// DecodeVersionNonce is an re-implementation of Encoding.sol#decodeVersionedNonce.
-// If the nonce is greater than 32 bytes (solidity uint256), bytes [32:] are ignored
-func DecodeVersionedNonce(nonce *big.Int) (uint16, *big.Int) {
-	nonceBytes := nonce.Bytes()
-	nonceByteLen := len(nonceBytes)
-	if nonceByteLen < 30 {
-		// version is 0x0000
-		return 0, nonce
-	} else if nonceByteLen == 31 {
-		// version is 0x00[01..ff]
-		return uint16(nonceBytes[0]), new(big.Int).SetBytes(nonceBytes[1:])
-	} else {
-		// fully specified
-		version := binary.BigEndian.Uint16(nonceBytes[:2])
-		return version, new(big.Int).SetBytes(nonceBytes[2:])
-	}
-}

indexer/processor/l2_to_l1_message_passer.go

-package processor
-
-import (
-	"github.com/ethereum-optimism/optimism/indexer/database"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-)
-
-type L2ToL1MessagePasserMessagePassed struct {
-	*bindings.L2ToL1MessagePasserMessagePassed
-	Event *database.ContractEvent
-}
-
-func L2ToL1MessagePasserMessagesPassed(events *ProcessedContractEvents) ([]L2ToL1MessagePasserMessagePassed, error) {
-	l2ToL1MessagePasserAbi, err := bindings.L2ToL1MessagePasserMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	eventName := "MessagePassed"
-	processedMessagePassedEvents := events.eventsBySignature[l2ToL1MessagePasserAbi.Events[eventName].ID]
-	messagesPassed := make([]L2ToL1MessagePasserMessagePassed, len(processedMessagePassedEvents))
-	for i, messagePassedEvent := range processedMessagePassedEvents {
-		log := messagePassedEvent.RLPLog
-
-		var messagePassed bindings.L2ToL1MessagePasserMessagePassed
-		messagePassed.Raw = *log
-		err := UnpackLog(&messagePassed, log, eventName, l2ToL1MessagePasserAbi)
-		if err != nil {
-			return nil, err
-		}
-
-		messagesPassed[i] = L2ToL1MessagePasserMessagePassed{
-			L2ToL1MessagePasserMessagePassed: &messagePassed,
-			Event:                            messagePassedEvent,
-		}
-	}
-
-	return messagesPassed, nil
-}

indexer/processor/optimism_portal.go

-package processor
-
-import (
-	"errors"
-	"math/big"
-
-	"github.com/ethereum-optimism/optimism/indexer/database"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
-
-	"github.com/ethereum/go-ethereum/core/types"
-)
-
-type OptimismPortalTransactionDepositEvent struct {
-	*bindings.OptimismPortalTransactionDeposited
-	DepositTx *types.DepositTx
-	Event     *database.ContractEvent
-}
-
-type OptimismPortalWithdrawalProvenEvent struct {
-	*bindings.OptimismPortalWithdrawalProven
-	Event *database.ContractEvent
-}
-
-type OptimismPortalWithdrawalFinalizedEvent struct {
-	*bindings.OptimismPortalWithdrawalFinalized
-	Event *database.ContractEvent
-}
-
-type OptimismPortalProvenWithdrawal struct {
-	OutputRoot    [32]byte
-	Timestamp     *big.Int
-	L2OutputIndex *big.Int
-}
-
-func OptimismPortalTransactionDepositEvents(events *ProcessedContractEvents) ([]OptimismPortalTransactionDepositEvent, error) {
-	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	eventName := "TransactionDeposited"
-	if optimismPortalAbi.Events[eventName].ID != derive.DepositEventABIHash {
-		return nil, errors.New("op-node deposit event abi hash & optimism portal tx deposit mismatch")
-	}
-
-	processedTxDepositedEvents := events.eventsBySignature[derive.DepositEventABIHash]
-	txDeposits := make([]OptimismPortalTransactionDepositEvent, len(processedTxDepositedEvents))
-	for i, txDepositEvent := range processedTxDepositedEvents {
-		log := txDepositEvent.RLPLog
-
-		depositTx, err := derive.UnmarshalDepositLogEvent(log)
-		if err != nil {
-			return nil, err
-		}
-
-		var txDeposit bindings.OptimismPortalTransactionDeposited
-		txDeposit.Raw = *log
-		err = UnpackLog(&txDeposit, log, eventName, optimismPortalAbi)
-		if err != nil {
-			return nil, err
-		}
-
-		txDeposits[i] = OptimismPortalTransactionDepositEvent{
-			OptimismPortalTransactionDeposited: &txDeposit,
-			DepositTx:                          depositTx,
-			Event:                              txDepositEvent,
-		}
-	}
-
-	return txDeposits, nil
-}
-
-func OptimismPortalWithdrawalProvenEvents(events *ProcessedContractEvents) ([]OptimismPortalWithdrawalProvenEvent, error) {
-	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	eventName := "WithdrawalProven"
-	processedWithdrawalProvenEvents := events.eventsBySignature[optimismPortalAbi.Events[eventName].ID]
-	provenEvents := make([]OptimismPortalWithdrawalProvenEvent, len(processedWithdrawalProvenEvents))
-	for i, provenEvent := range processedWithdrawalProvenEvents {
-		log := provenEvent.RLPLog
-
-		var withdrawalProven bindings.OptimismPortalWithdrawalProven
-		withdrawalProven.Raw = *log
-		err := UnpackLog(&withdrawalProven, log, eventName, optimismPortalAbi)
-		if err != nil {
-			return nil, err
-		}
-
-		provenEvents[i] = OptimismPortalWithdrawalProvenEvent{
-			OptimismPortalWithdrawalProven: &withdrawalProven,
-			Event:                          provenEvent,
-		}
-	}
-
-	return provenEvents, nil
-}
-
-func OptimismPortalWithdrawalFinalizedEvents(events *ProcessedContractEvents) ([]OptimismPortalWithdrawalFinalizedEvent, error) {
-	optimismPortalAbi, err := bindings.OptimismPortalMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	eventName := "WithdrawalFinalized"
-	processedWithdrawalFinalizedEvents := events.eventsBySignature[optimismPortalAbi.Events[eventName].ID]
-	finalizedEvents := make([]OptimismPortalWithdrawalFinalizedEvent, len(processedWithdrawalFinalizedEvents))
-	for i, finalizedEvent := range processedWithdrawalFinalizedEvents {
-		log := finalizedEvent.RLPLog
-
-		var withdrawalFinalized bindings.OptimismPortalWithdrawalFinalized
-		err := UnpackLog(&withdrawalFinalized, log, eventName, optimismPortalAbi)
-		if err != nil {
-			return nil, err
-		}
-
-		finalizedEvents[i] = OptimismPortalWithdrawalFinalizedEvent{
-			OptimismPortalWithdrawalFinalized: &withdrawalFinalized,
-			Event:                             finalizedEvent,
-		}
-	}
-
-	return finalizedEvents, nil
-}

indexer/processor/processor.go

-package processor
-
-import (
-	"context"
-	"time"
-
-	"github.com/ethereum-optimism/optimism/indexer/database"
-	"github.com/ethereum-optimism/optimism/indexer/node"
-
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-const (
-	defaultLoopInterval     = 5 * time.Second
-	defaultHeaderBufferSize = 500
-)
-
-// ProcessFn is the the entrypoint for processing a batch of headers.
-// In the event of failure, database operations are rolled back
-type ProcessFn func(*database.DB, []*types.Header) error
-
-type processor struct {
-	headerTraversal *node.HeaderTraversal
-
-	db         *database.DB
-	processFn  ProcessFn
-	processLog log.Logger
-
-	paused                bool
-	latestProcessedHeader *types.Header
-}
-
-// Start kicks off the processing loop. This is a block operation
-// unless the processor encountering an error, abrupting the loop,
-// or the supplied context is cancelled.
-func (p *processor) Start(ctx context.Context) error {
-	done := ctx.Done()
-	pollTicker := time.NewTicker(defaultLoopInterval)
-	defer pollTicker.Stop()
-
-	p.processLog.Info("starting processor...")
-	var unprocessedHeaders []*types.Header
-	for {
-		select {
-		case <-done:
-			p.processLog.Info("stopping processor")
-			return nil
-
-		case <-pollTicker.C:
-			if p.paused {
-				p.processLog.Warn("processor is paused...")
-				continue
-			}
-
-			if len(unprocessedHeaders) == 0 {
-				newHeaders, err := p.headerTraversal.NextFinalizedHeaders(defaultHeaderBufferSize)
-				if err != nil {
-					p.processLog.Error("error querying for headers", "err", err)
-					continue
-				} else if len(newHeaders) == 0 {
-					// Logged as an error since this loop should be operating at a longer interval than the provider
-					p.processLog.Error("no new headers. processor unexpectedly at head...")
-					continue
-				}
-
-				unprocessedHeaders = newHeaders
-			} else {
-				p.processLog.Info("retrying previous batch")
-			}
-
-			firstHeader := unprocessedHeaders[0]
-			lastHeader := unprocessedHeaders[len(unprocessedHeaders)-1]
-			batchLog := p.processLog.New("batch_start_block_number", firstHeader.Number, "batch_end_block_number", lastHeader.Number)
-			err := p.db.Transaction(func(db *database.DB) error {
-				batchLog.Info("processing batch")
-				return p.processFn(db, unprocessedHeaders)
-			})
-
-			// Eventually, we want to halt the processor on any error rather than rely
-			// on this loop for retry functionality.
-			if err != nil {
-				batchLog.Warn("error processing batch. no operations committed", "err", err)
-			} else {
-				batchLog.Info("fully committed batch")
-
-				unprocessedHeaders = nil
-				p.latestProcessedHeader = lastHeader
-			}
-		}
-	}
-}
-
-func (p processor) LatestProcessedHeader() *types.Header {
-	return p.latestProcessedHeader
-}
-
-// Useful ONLY for tests!
-
-func (p *processor) PauseForTest() {
-	p.paused = true
-}
-
-func (p *processor) ResumeForTest() {
-	p.paused = false
-}

indexer/processor/standard_bridge.go

-package processor
-
-import (
-	"bytes"
-	"errors"
-
-	"github.com/ethereum-optimism/optimism/indexer/database"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-type StandardBridgeInitiatedEvent struct {
-	// We hardcode to ERC20 since ETH can be pseudo-represented as an ERC20 utilizing
-	// the hardcoded ETH address
-	*bindings.StandardBridgeERC20BridgeInitiated
-
-	CrossDomainMessageHash common.Hash
-	Event                  *database.ContractEvent
-}
-
-type StandardBridgeFinalizedEvent struct {
-	// We hardcode to ERC20 since ETH can be pseudo-represented as an ERC20 utilizing
-	// the hardcoded ETH address
-	*bindings.StandardBridgeERC20BridgeFinalized
-
-	CrossDomainMessageHash common.Hash
-	Event                  *database.ContractEvent
-}
-
-// StandardBridgeInitiatedEvents extracts all initiated bridge events from the contracts that follow the StandardBridge ABI. The
-// correlated CrossDomainMessenger nonce is also parsed from the associated messenger events.
-func StandardBridgeInitiatedEvents(events *ProcessedContractEvents) ([]StandardBridgeInitiatedEvent, error) {
-	ethBridgeInitiatedEvents, err := _standardBridgeInitiatedEvents[bindings.StandardBridgeETHBridgeInitiated](events)
-	if err != nil {
-		return nil, err
-	}
-
-	erc20BridgeInitiatedEvents, err := _standardBridgeInitiatedEvents[bindings.StandardBridgeERC20BridgeInitiated](events)
-	if err != nil {
-		return nil, err
-	}
-
-	return append(ethBridgeInitiatedEvents, erc20BridgeInitiatedEvents...), nil
-}
-
-// StandardBridgeFinalizedEvents extracts all finalization bridge events from the contracts that follow the StandardBridge ABI. The
-// correlated CrossDomainMessenger nonce is also parsed by looking at the parameters of the corresponding relayMessage transaction data.
-func StandardBridgeFinalizedEvents(events *ProcessedContractEvents) ([]StandardBridgeFinalizedEvent, error) {
-	ethBridgeFinalizedEvents, err := _standardBridgeFinalizedEvents[bindings.StandardBridgeETHBridgeFinalized](events)
-	if err != nil {
-		return nil, err
-	}
-
-	erc20BridgeFinalizedEvents, err := _standardBridgeFinalizedEvents[bindings.StandardBridgeERC20BridgeFinalized](events)
-	if err != nil {
-		return nil, err
-	}
-
-	return append(ethBridgeFinalizedEvents, erc20BridgeFinalizedEvents...), nil
-}
-
-// parse out eth or erc20 bridge initiated events
-func _standardBridgeInitiatedEvents[BridgeEvent bindings.StandardBridgeETHBridgeInitiated | bindings.StandardBridgeERC20BridgeInitiated](
-	events *ProcessedContractEvents,
-) ([]StandardBridgeInitiatedEvent, error) {
-	standardBridgeABI, err := bindings.StandardBridgeMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	crossDomainMessengerABI, err := bindings.CrossDomainMessengerMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	sentMessageEventAbi := crossDomainMessengerABI.Events["SentMessage"]
-	sentMessageExtensionEventAbi := crossDomainMessengerABI.Events["SentMessageExtension1"]
-
-	var tmp BridgeEvent
-	var eventName string
-	var finalizeMethodName string
-	switch any(tmp).(type) {
-	case bindings.StandardBridgeETHBridgeInitiated:
-		eventName = "ETHBridgeInitiated"
-		finalizeMethodName = "finalizeBridgeETH"
-	case bindings.StandardBridgeERC20BridgeInitiated:
-		eventName = "ERC20BridgeInitiated"
-		finalizeMethodName = "finalizeBridgeERC20"
-	default:
-		panic("should not be here")
-	}
-
-	processedInitiatedBridgeEvents := events.eventsBySignature[standardBridgeABI.Events[eventName].ID]
-	initiatedBridgeEvents := make([]StandardBridgeInitiatedEvent, len(processedInitiatedBridgeEvents))
-	for i, bridgeInitiatedEvent := range processedInitiatedBridgeEvents {
-		log := bridgeInitiatedEvent.RLPLog
-
-		var bridgeData BridgeEvent
-		err := UnpackLog(&bridgeData, log, eventName, standardBridgeABI)
-		if err != nil {
-			return nil, err
-		}
-
-		// Look for the sent message event to compute the message hash of the relayed tx
-		//   - L1: BridgeInitiated -> Portal#DepositTransaction -> SentMessage ...
-		//   - L1: BridgeInitiated -> L2ToL1MessagePasser#MessagePassed -> SentMessage ...
-		var sentMsgData bindings.CrossDomainMessengerSentMessage
-		sentMsgLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 2}].RLPLog
-		if sentMsgLog.Topics[0] != sentMessageEventAbi.ID {
-			return nil, errors.New("unexpected bridge event ordering")
-		}
-		sentMsgData.Raw = *sentMsgLog
-		err = UnpackLog(&sentMsgData, sentMsgLog, sentMessageEventAbi.Name, crossDomainMessengerABI)
-		if err != nil {
-			return nil, err
-		}
-
-		var sentMsgExtensionData bindings.CrossDomainMessengerSentMessageExtension1
-		sentMsgExtensionLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 3}].RLPLog
-		if sentMsgExtensionLog.Topics[0] != sentMessageExtensionEventAbi.ID {
-			return nil, errors.New("unexpected bridge event ordering")
-		}
-		sentMsgData.Raw = *sentMsgLog
-		err = UnpackLog(&sentMsgExtensionData, sentMsgExtensionLog, sentMessageExtensionEventAbi.Name, crossDomainMessengerABI)
-		if err != nil {
-			return nil, err
-		}
-
-		msgHash, err := CrossDomainMessageHash(crossDomainMessengerABI, &sentMsgData, sentMsgExtensionData.Value)
-		if err != nil {
-			return nil, err
-		}
-
-		var erc20BridgeData *bindings.StandardBridgeERC20BridgeInitiated
-		var expectedCrossDomainMessage []byte
-		switch any(bridgeData).(type) {
-		case bindings.StandardBridgeETHBridgeInitiated:
-			ethBridgeData := any(bridgeData).(bindings.StandardBridgeETHBridgeInitiated)
-			expectedCrossDomainMessage, err = standardBridgeABI.Pack(finalizeMethodName, ethBridgeData.From, ethBridgeData.To, ethBridgeData.Amount, ethBridgeData.ExtraData)
-			if err != nil {
-				return nil, err
-			}
-
-			// represent eth bridge as an erc20
-			erc20BridgeData = &bindings.StandardBridgeERC20BridgeInitiated{
-				Raw: *log,
-				// Represent ETH using the hardcoded address
-				LocalToken: predeploys.LegacyERC20ETHAddr, RemoteToken: predeploys.LegacyERC20ETHAddr,
-				// Bridge data
-				From: ethBridgeData.From, To: ethBridgeData.To, Amount: ethBridgeData.Amount, ExtraData: ethBridgeData.ExtraData,
-			}
-
-		case bindings.StandardBridgeERC20BridgeInitiated:
-			_temp := any(bridgeData).(bindings.StandardBridgeERC20BridgeInitiated)
-			erc20BridgeData = &_temp
-			erc20BridgeData.Raw = *log
-			expectedCrossDomainMessage, err = standardBridgeABI.Pack(finalizeMethodName, erc20BridgeData.RemoteToken, erc20BridgeData.LocalToken, erc20BridgeData.From, erc20BridgeData.To, erc20BridgeData.Amount, erc20BridgeData.ExtraData)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		if !bytes.Equal(sentMsgData.Message, expectedCrossDomainMessage) {
-			return nil, errors.New("bridge cross domain message mismatch")
-		}
-
-		initiatedBridgeEvents[i] = StandardBridgeInitiatedEvent{
-			StandardBridgeERC20BridgeInitiated: erc20BridgeData,
-			CrossDomainMessageHash:             msgHash,
-			Event:                              bridgeInitiatedEvent,
-		}
-	}
-
-	return initiatedBridgeEvents, nil
-}
-
-// parse out eth or erc20 bridge finalization events
-func _standardBridgeFinalizedEvents[BridgeEvent bindings.StandardBridgeETHBridgeFinalized | bindings.StandardBridgeERC20BridgeFinalized](
-	events *ProcessedContractEvents,
-) ([]StandardBridgeFinalizedEvent, error) {
-	standardBridgeABI, err := bindings.StandardBridgeMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	crossDomainMessengerABI, err := bindings.CrossDomainMessengerMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-
-	relayedMessageEventAbi := crossDomainMessengerABI.Events["RelayedMessage"]
-
-	var bridgeData BridgeEvent
-	var eventName string
-	switch any(bridgeData).(type) {
-	case bindings.StandardBridgeETHBridgeFinalized:
-		eventName = "ETHBridgeFinalized"
-	case bindings.StandardBridgeERC20BridgeFinalized:
-		eventName = "ERC20BridgeFinalized"
-	default:
-		panic("should not be here")
-	}
-
-	processedFinalizedBridgeEvents := events.eventsBySignature[standardBridgeABI.Events[eventName].ID]
-	finalizedBridgeEvents := make([]StandardBridgeFinalizedEvent, len(processedFinalizedBridgeEvents))
-	for i, bridgeFinalizedEvent := range processedFinalizedBridgeEvents {
-		log := bridgeFinalizedEvent.RLPLog
-
-		var bridgeData BridgeEvent
-		err := UnpackLog(&bridgeData, log, eventName, standardBridgeABI)
-		if err != nil {
-			return nil, err
-		}
-
-		// Look for the RelayedMessage event that follows right after the BridgeFinalized Event
-		var relayedMsgData bindings.CrossDomainMessengerRelayedMessage
-		relayedMsgLog := events.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index + 1}].RLPLog
-		if relayedMsgLog.Topics[0] != relayedMessageEventAbi.ID {
-			return nil, errors.New("unexpected bridge event ordering")
-		}
-		err = UnpackLog(&relayedMsgData, relayedMsgLog, relayedMessageEventAbi.Name, crossDomainMessengerABI)
-		if err != nil {
-			return nil, err
-		}
-
-		var erc20BridgeData *bindings.StandardBridgeERC20BridgeFinalized
-		switch any(bridgeData).(type) {
-		case bindings.StandardBridgeETHBridgeFinalized:
-			ethBridgeData := any(bridgeData).(bindings.StandardBridgeETHBridgeFinalized)
-			erc20BridgeData = &bindings.StandardBridgeERC20BridgeFinalized{
-				Raw: *log,
-				// Represent ETH using the hardcoded address
-				LocalToken: predeploys.LegacyERC20ETHAddr, RemoteToken: predeploys.LegacyERC20ETHAddr,
-				// Bridge data
-				From: ethBridgeData.From, To: ethBridgeData.To, Amount: ethBridgeData.Amount, ExtraData: ethBridgeData.ExtraData,
-			}
-
-		case bindings.StandardBridgeERC20BridgeFinalized:
-			_temp := any(bridgeData).(bindings.StandardBridgeERC20BridgeFinalized)
-			erc20BridgeData = &_temp
-			erc20BridgeData.Raw = *log
-		}
-
-		finalizedBridgeEvents[i] = StandardBridgeFinalizedEvent{
-			StandardBridgeERC20BridgeFinalized: erc20BridgeData,
-			CrossDomainMessageHash:             relayedMsgData.MsgHash,
-			Event:                              bridgeFinalizedEvent,
-		}
-	}
-
-	return finalizedBridgeEvents, nil
-}

indexer/processors/bridge.go

+package processors
+
+import (
+	"context"
+	"errors"
+	"math/big"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/indexer/config"
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/indexer/processors/bridge"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type BridgeProcessor struct {
+	log         log.Logger
+	db          *database.DB
+	chainConfig config.ChainConfig
+
+	// NOTE: We'll need this processor to handle for reorgs events.
+
+	LatestL1Header *types.Header
+	LatestL2Header *types.Header
+}
+
+func NewBridgeProcessor(log log.Logger, db *database.DB, chainConfig config.ChainConfig) (*BridgeProcessor, error) {
+	log = log.New("processor", "bridge")
+
+	latestL1Header, err := bridge.L1LatestBridgeEventHeader(db, chainConfig)
+	if err != nil {
+		return nil, err
+	}
+	latestL2Header, err := bridge.L2LatestBridgeEventHeader(db)
+	if err != nil {
+		return nil, err
+	}
+
+	// Since the bridge processor indexes events based on epochs, there's
+	// no scenario in which we have indexed L2 data with no L1 data.
+	//
+	// NOTE: Technically there is an exception if our bridging contracts are
+	// used to bridges native from L2 and an op-chain happens to launch where
+	// only L2 native bridge events have occurred. This is a rare situation now
+	// and it's worth the assertion as an integrity check. We can revisit this
+	// as more chains launch with primarily L2-native activity.
+	if latestL1Header == nil && latestL2Header != nil {
+		log.Error("detected indexed L2 bridge activity with no indexed L1 state", "l2_block_number", latestL2Header.Number)
+		return nil, errors.New("detected indexed L2 bridge activity with no indexed L1 state")
+	}
+
+	if latestL1Header == nil && latestL2Header == nil {
+		log.Info("no indexed state, starting from genesis")
+	} else {
+		log.Info("detected the latest indexed state", "l1_block_number", latestL1Header.Number, "l2_block_number", latestL2Header.Number)
+	}
+
+	return &BridgeProcessor{log, db, chainConfig, latestL1Header, latestL2Header}, nil
+}
+
+func (b *BridgeProcessor) Start(ctx context.Context) error {
+	done := ctx.Done()
+
+	// NOTE: This should run on same iterval as L1 ETL rather than as finding the
+	// lasted epoch is constrained to how much L1 data we've indexed.
+	pollTicker := time.NewTicker(5 * time.Second)
+	defer pollTicker.Stop()
+
+	// In order to ensure all seen bridge finalization events correspond with seen
+	// bridge initiated events, we establish a shared marker between L1 and L2 when
+	// processing events.
+	//
+	// As L1 and L2 blocks are indexed, the highest indexed L2 block starting a new
+	// sequencing epoch and corresponding L1 origin that has also been indexed
+	// serves as this shared marker.
+
+	// TODOs:
+	// 	  1. Fix Logging. Should be clear if we're looking at L1 or L2 side of things
+
+	b.log.Info("starting bridge processor...")
+	for {
+		select {
+		case <-done:
+			b.log.Info("stopping bridge processor")
+			return nil
+
+		case <-pollTicker.C:
+			latestEpoch, err := b.db.Blocks.LatestEpoch()
+			if err != nil {
+				return err
+			}
+			if latestEpoch == nil {
+				if b.LatestL1Header != nil {
+					// Once we have some satte `latestEpoch` should never return nil.
+					b.log.Error("started with indexed bridge state, but no blocks epochs returned", "latest_bridge_l1_block_number", b.LatestL1Header.Number)
+					return errors.New("started with indexed bridge state, but no blocks epochs returned")
+				} else {
+					b.log.Warn("no indexed block state. waiting...")
+					continue
+				}
+			}
+
+			if b.LatestL1Header != nil && latestEpoch.L1BlockHeader.Hash == b.LatestL1Header.Hash() {
+				// Marked as a warning since the bridge should always be processing at least 1 new epoch
+				b.log.Warn("all available epochs indexed by the bridge", "latest_epoch_number", b.LatestL1Header.Number)
+				continue
+			}
+
+			toL1Height, toL2Height := latestEpoch.L1BlockHeader.Number.Int, latestEpoch.L2BlockHeader.Number.Int
+			fromL1Height, fromL2Height := big.NewInt(0), big.NewInt(0)
+			if b.LatestL1Header != nil {
+				// `NewBridgeProcessor` ensures that LatestL2Header must not be nil if LatestL1Header is set
+				fromL1Height = new(big.Int).Add(b.LatestL1Header.Number, big.NewInt(1))
+				fromL2Height = new(big.Int).Add(b.LatestL2Header.Number, big.NewInt(1))
+			}
+
+			batchLog := b.log.New("epoch_start_number", fromL1Height, "epoch_end_number", toL1Height)
+			batchLog.Info("scanning bridge events")
+			err = b.db.Transaction(func(tx *database.DB) error {
+				l1BridgeLog := b.log.New("from_l1_block_number", fromL1Height, "to_l1_block_number", toL1Height)
+				l2BridgeLog := b.log.New("from_l2_block_number", fromL2Height, "to_l2_block_number", toL2Height)
+
+				// First, find all possible initiated bridge events
+				if err := bridge.L1ProcessInitiatedBridgeEvents(l1BridgeLog, tx, b.chainConfig, fromL1Height, toL1Height); err != nil {
+					return err
+				}
+				if err := bridge.L2ProcessInitiatedBridgeEvents(l2BridgeLog, tx, fromL2Height, toL2Height); err != nil {
+					return err
+				}
+
+				// Now that all initiated events have been indexed, it is ensured that all finalization can find their counterpart.
+				if err := bridge.L1ProcessFinalizedBridgeEvents(l1BridgeLog, tx, b.chainConfig, fromL1Height, toL1Height); err != nil {
+					return err
+				}
+				if err := bridge.L2ProcessFinalizedBridgeEvents(l2BridgeLog, tx, fromL2Height, toL2Height); err != nil {
+					return err
+				}
+
+				// a-ok
+				return nil
+			})
+
+			if err != nil {
+				// Try again on a subsequent interval
+				batchLog.Error("unable to index new bridge events", "err", err)
+			} else {
+				batchLog.Info("done indexing new bridge events", "latest_l1_block_number", toL1Height, "latest_l2_block_number", toL2Height)
+				b.LatestL1Header = latestEpoch.L1BlockHeader.RLPHeader.Header()
+				b.LatestL2Header = latestEpoch.L2BlockHeader.RLPHeader.Header()
+			}
+		}
+	}
+}

indexer/processors/bridge/types.go

+package bridge
+
+import "github.com/ethereum/go-ethereum/common"
+
+type logKey struct {
+	BlockHash common.Hash
+	LogIndex  uint64
+}

indexer/processors/contracts/l2_to_l1_message_passer.go

+package contracts
+
+import (
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type L2ToL1MessagePasserMessagePassed struct {
+	Event          *database.ContractEvent
+	WithdrawalHash common.Hash
+	GasLimit       database.U256
+	Nonce          database.U256
+	Tx             database.Transaction
+}
+
+func L2ToL1MessagePasserMessagePassedEvents(contractAddress common.Address, db *database.DB, fromHeight, toHeight *big.Int) ([]L2ToL1MessagePasserMessagePassed, error) {
+	l2ToL1MessagePasserAbi, err := bindings.L2ToL1MessagePasserMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
+	messagePassedAbi := l2ToL1MessagePasserAbi.Events["MessagePassed"]
+	contractEventFilter := database.ContractEvent{ContractAddress: contractAddress, EventSignature: messagePassedAbi.ID}
+	messagePassedEvents, err := db.ContractEvents.L2ContractEventsWithFilter(contractEventFilter, fromHeight, toHeight)
+	if err != nil {
+		return nil, err
+	}
+
+	messagesPassed := make([]L2ToL1MessagePasserMessagePassed, len(messagePassedEvents))
+	for i := range messagePassedEvents {
+		messagePassed := bindings.L2ToL1MessagePasserMessagePassed{Raw: *messagePassedEvents[i].RLPLog}
+		err := UnpackLog(&messagePassed, messagePassedEvents[i].RLPLog, messagePassedAbi.Name, l2ToL1MessagePasserAbi)
+		if err != nil {
+			return nil, err
+		}
+
+		messagesPassed[i] = L2ToL1MessagePasserMessagePassed{
+			Event:          &messagePassedEvents[i].ContractEvent,
+			WithdrawalHash: messagePassed.WithdrawalHash,
+			Nonce:          database.U256{Int: messagePassed.Nonce},
+			GasLimit:       database.U256{Int: messagePassed.GasLimit},
+			Tx: database.Transaction{
+				FromAddress: messagePassed.Sender,
+				ToAddress:   messagePassed.Target,
+				Amount:      database.U256{Int: messagePassed.Value},
+				Data:        messagePassed.Data,
+				Timestamp:   messagePassedEvents[i].Timestamp,
+			},
+		}
+	}
+
+	return messagesPassed, nil
+}

indexer/processor/contract_events.go → indexer/processors/contracts/utils.go

-package processor
+package contracts
 
 import (
+	"encoding/binary"
 	"errors"
 	"fmt"
-
-	"github.com/ethereum-optimism/optimism/indexer/database"
+	"math/big"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
-type ProcessedContractEventLogIndexKey struct {
-	blockHash common.Hash
-	index     uint
-}
-
-type ProcessedContractEvents struct {
-	events            []*database.ContractEvent
-	eventsBySignature map[common.Hash][]*database.ContractEvent
-	eventByLogIndex   map[ProcessedContractEventLogIndexKey]*database.ContractEvent
-}
-
-func NewProcessedContractEvents() *ProcessedContractEvents {
-	return &ProcessedContractEvents{
-		events:            []*database.ContractEvent{},
-		eventsBySignature: make(map[common.Hash][]*database.ContractEvent),
-		eventByLogIndex:   make(map[ProcessedContractEventLogIndexKey]*database.ContractEvent),
+// DecodeVersionNonce is an re-implementation of Encoding.sol#decodeVersionedNonce.
+// If the nonce is greater than 32 bytes (solidity uint256), bytes [32:] are ignored
+func DecodeVersionedNonce(nonce *big.Int) (uint16, *big.Int) {
+	nonceBytes := nonce.Bytes()
+	nonceByteLen := len(nonceBytes)
+	if nonceByteLen < 30 {
+		// version is 0x0000
+		return 0, nonce
+	} else if nonceByteLen == 31 {
+		// version is 0x00[01..ff]
+		return uint16(nonceBytes[0]), new(big.Int).SetBytes(nonceBytes[1:])
+	} else {
+		// fully specified
+		version := binary.BigEndian.Uint16(nonceBytes[:2])
+		return version, new(big.Int).SetBytes(nonceBytes[2:])
 	}
 }
 
-func (p *ProcessedContractEvents) AddLog(log *types.Log, time uint64) *database.ContractEvent {
-	event := database.ContractEventFromLog(log, time)
-	emptyHash := common.Hash{}
-
-	p.events = append(p.events, &event)
-	p.eventByLogIndex[ProcessedContractEventLogIndexKey{log.BlockHash, log.Index}] = &event
-	if event.EventSignature != emptyHash {
-		p.eventsBySignature[event.EventSignature] = append(p.eventsBySignature[event.EventSignature], &event)
-	}
-
-	return &event
-}
-
 func UnpackLog(out interface{}, log *types.Log, name string, contractAbi *abi.ABI) error {
 	eventAbi, ok := contractAbi.Events[name]
 	if !ok {

op-batcher/batcher/batch_submitter.go

@@ -68,7 +68,7 @@ func Main(version string, cliCtx *cli.Context) error {
 		l.Info("starting metrics server", "addr", metricsCfg.ListenAddr, "port", metricsCfg.ListenPort)
 		go func() {
 			if err := m.Serve(ctx, metricsCfg.ListenAddr, metricsCfg.ListenPort); err != nil {
-				l.Error("error starting metrics server", err)
+				l.Error("error starting metrics server", "err", err)
 			}
 		}()
 		m.StartBalanceMetrics(ctx, l, batchSubmitter.L1Client, batchSubmitter.TxManager.From())