Merge branch 'develop' into cleanup/devnet

d48f327b · mergify[bot] · GitHub · d3380c89 · c3cff501 · d48f327b
Commit d48f327b authored Jun 14, 2023 by mergify[bot] Committed by GitHub Jun 14, 2023
65 changed files
--- a/.changeset/smooth-bulldogs-hear.md
+++ b/.changeset/smooth-bulldogs-hear.md
+---
+'@eth-optimism/chain-mon': patch
+---
+Fixed an issue with logging the wrong timestamp.
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -82,7 +82,6 @@ jobs:
            - "packages/chain-mon/node_modules"
            - "packages/common-ts/node_modules"
            - "packages/contracts-bedrock/node_modules"
-            - "packages/contracts-governance/node_modules"
            - "packages/contracts-periphery/node_modules"
            - "packages/core-utils/node_modules"
            - "packages/drippie-mon/node_modules"
@@ -584,7 +583,6 @@ jobs:
            VITE_E2E_RPC_URL_L1: http://localhost:8545
            VITE_E2E_RPC_URL_L2: http://localhost:9545
  bedrock-markdown:
    machine:
      image: ubuntu-2204:2022.07.1
@@ -1070,13 +1068,6 @@ workflows:
          package_name: common-ts
          requires:
            - yarn-monorepo
-      - js-lint-test:
-          name: contracts-tests
-          coverage_flag: contracts-tests
-          package_name: contracts
-          dependencies: hardhat-deploy-config
-          requires:
-            - yarn-monorepo
      - js-lint-test:
          name: core-utils-tests
          coverage_flag: core-utils-tests

--- a/indexer/Dockerfile
+++ b/indexer/Dockerfile
-FROM golang:1.18.0-alpine3.15 as builder
+FROM golang:1.19.0-alpine3.15 as builder
 RUN apk add --no-cache make gcc musl-dev linux-headers git jq bash

--- a/indexer/Makefile
+++ b/indexer/Makefile
@@ -7,10 +7,6 @@ LDFLAGSSTRING +=-X main.GitDate=$(GITDATE)
 LDFLAGSSTRING +=-X main.GitVersion=$(GITVERSION)
 LDFLAGS := -ldflags "$(LDFLAGSSTRING)"
-# Note: Requires legacy contracts to be built before
-# running and binding-related Make targets.
-SCC_ABI_ARTIFACT = ../packages/contracts/artifacts/contracts/L1/rollup/StateCommitmentChain.sol/StateCommitmentChain.json
 indexer:
 	env GO111MODULE=on go build -v $(LDFLAGS) ./cmd/indexer
@@ -26,24 +22,6 @@ test:
 lint:
 	golangci-lint run ./...
-bindings: bindings-scc
-bindings-scc:
-	$(eval temp := $(shell mktemp))
-	cat $(SCC_ABI_ARTIFACT) \
-		| jq -r .bytecode > $(temp)
-	cat $(SCC_ABI_ARTIFACT) \
-		| jq .abi \
-		| abigen --pkg scc \
-		--abi - \
-		--out bindings/scc/statecommitmentchain.go \
-		--type StateCommitmentChain \
-		--bin $(temp)
-	rm $(temp)
 .PHONY: \
 	indexer \
 	indexer-refresh \

--- a/indexer/bindings/legacy/scc/statecommitmentchain.go
+++ b/indexer/bindings/legacy/scc/statecommitmentchain.go
--- a/indexer/contracts/ERC20.sol/ERC20.json
+++ b/indexer/contracts/ERC20.sol/ERC20.json
--- a/indexer/go.mod
+++ b/indexer/go.mod
@@ -2,13 +2,13 @@ module github.com/ethereum-optimism/optimism/indexer
 go 1.19
-replace github.com/ethereum/go-ethereum v1.11.4 => github.com/ethereum-optimism/op-geth v1.11.2-de8c5df46.0.20230321002540-11f0554a4313
+replace github.com/ethereum/go-ethereum v1.11.6 => github.com/ethereum-optimism/op-geth v1.101106.0-rc.2
 require (
 	github.com/BurntSushi/toml v1.3.0
-	github.com/ethereum-optimism/optimism v0.2.1-0.20230326215719-b8e2fa58359a
+	github.com/ethereum-optimism/optimism v1.0.9
-	github.com/ethereum/go-ethereum v1.11.4
+	github.com/ethereum/go-ethereum v1.11.6
-	github.com/go-chi/chi v1.5.4
+	github.com/go-chi/chi/v5 v5.0.8
 	github.com/google/uuid v1.3.0
 	github.com/gorilla/mux v1.8.0
 	github.com/jackc/pgtype v1.14.0
@@ -57,7 +57,6 @@ require (
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 // indirect
 	github.com/getsentry/sentry-go v0.18.0 // indirect
-	github.com/go-chi/chi/v5 v5.0.8 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 // indirect
@@ -67,7 +66,7 @@ require (
 	github.com/golang-jwt/jwt/v4 v4.4.2 // indirect
 	github.com/golang/mock v1.6.0 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
+	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
 	github.com/google/gopacket v1.1.19 // indirect
 	github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
@@ -78,10 +77,10 @@ require (
 	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
 	github.com/hashicorp/golang-lru/v2 v2.0.1 // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
-	github.com/holiman/uint256 v1.2.0 // indirect
+	github.com/holiman/uint256 v1.2.2-0.20230321075855-87b91420868c // indirect
 	github.com/huin/goupnp v1.1.0 // indirect
-	github.com/influxdata/influxdb v1.8.3 // indirect
 	github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect
+	github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c // indirect
 	github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
 	github.com/ipfs/go-cid v0.3.2 // indirect
 	github.com/ipfs/go-datastore v0.6.0 // indirect
@@ -174,15 +173,16 @@ require (
 	go.uber.org/zap v1.24.0 // indirect
 	golang.org/x/crypto v0.8.0 // indirect
 	golang.org/x/exp v0.0.0-20230213192124-5e25df0256eb // indirect
-	golang.org/x/mod v0.8.0 // indirect
+	golang.org/x/mod v0.9.0 // indirect
 	golang.org/x/net v0.9.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/sys v0.7.0 // indirect
 	golang.org/x/term v0.7.0 // indirect
 	golang.org/x/text v0.9.0 // indirect
 	golang.org/x/time v0.0.0-20220922220347-f3bd1da661af // indirect
-	golang.org/x/tools v0.6.0 // indirect
+	golang.org/x/tools v0.7.0 // indirect
 	google.golang.org/protobuf v1.28.1 // indirect
+	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

--- a/indexer/go.sum
+++ b/indexer/go.sum
--- a/indexer/services/addresses.go
+++ b/indexer/services/addresses.go
 package services
 import (
-	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	legacy_bindings "github.com/ethereum-optimism/optimism/op-bindings/legacy-bindings"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 type AddressManager interface {
 	L1StandardBridge() (common.Address, *bindings.L1StandardBridge)
-	StateCommitmentChain() (common.Address, *scc.StateCommitmentChain)
+	StateCommitmentChain() (common.Address, *legacy_bindings.StateCommitmentChain)
 	OptimismPortal() (common.Address, *bindings.OptimismPortal)
 }
 type LegacyAddresses struct {
 	l1SB     *bindings.L1StandardBridge
 	l1SBAddr common.Address
-	scc      *scc.StateCommitmentChain
+	scc      *legacy_bindings.StateCommitmentChain
 	sccAddr  common.Address
 }
@@ -40,7 +40,7 @@ func NewLegacyAddresses(client bind.ContractBackend, addrMgrAddr common.Address)
 	if err != nil {
 		return nil, err
 	}
-	sccContract, err := scc.NewStateCommitmentChain(sccAddr, client)
+	sccContract, err := legacy_bindings.NewStateCommitmentChain(sccAddr, client)
 	if err != nil {
 		return nil, err
 	}
@@ -57,7 +57,7 @@ func (a *LegacyAddresses) L1StandardBridge() (common.Address, *bindings.L1Standa
 	return a.l1SBAddr, a.l1SB
 }
-func (a *LegacyAddresses) StateCommitmentChain() (common.Address, *scc.StateCommitmentChain) {
+func (a *LegacyAddresses) StateCommitmentChain() (common.Address, *legacy_bindings.StateCommitmentChain) {
 	return a.sccAddr, a.scc
 }
@@ -96,7 +96,7 @@ func (b *BedrockAddresses) L1StandardBridge() (common.Address, *bindings.L1Stand
 	return b.l1SBAddr, b.l1SB
 }
-func (b *BedrockAddresses) StateCommitmentChain() (common.Address, *scc.StateCommitmentChain) {
+func (b *BedrockAddresses) StateCommitmentChain() (common.Address, *legacy_bindings.StateCommitmentChain) {
 	panic("SCC not configured on legacy networks - this is a programmer error")
 }

--- a/indexer/services/l1/bridge/bridge.go
+++ b/indexer/services/l1/bridge/bridge.go
@@ -5,10 +5,10 @@ import (
 	"errors"
 	"math/big"
-	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum-optimism/optimism/indexer/services"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	legacy_bindings "github.com/ethereum-optimism/optimism/op-bindings/legacy-bindings"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -90,9 +90,9 @@ func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs servi
 	return bridges, nil
 }
-func StateCommitmentChainScanner(client bind.ContractFilterer, addrs services.AddressManager) (*scc.StateCommitmentChainFilterer, error) {
+func StateCommitmentChainScanner(client bind.ContractFilterer, addrs services.AddressManager) (*legacy_bindings.StateCommitmentChainFilterer, error) {
 	sccAddr, _ := addrs.StateCommitmentChain()
-	filter, err := scc.NewStateCommitmentChainFilterer(sccAddr, client)
+	filter, err := legacy_bindings.NewStateCommitmentChainFilterer(sccAddr, client)
 	if err != nil {
 		return nil, err
 	}

--- a/indexer/services/l1/bridge/filter.go
+++ b/indexer/services/l1/bridge/filter.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
-	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
+	legacy_bindings "github.com/ethereum-optimism/optimism/op-bindings/legacy-bindings"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 )
@@ -14,7 +14,7 @@ var clientRetryInterval = 5 * time.Second
 // FilterStateBatchAppendedWithRetry retries the given func until it succeeds,
 // waiting for clientRetryInterval duration after every call.
-func FilterStateBatchAppendedWithRetry(ctx context.Context, filterer *scc.StateCommitmentChainFilterer, opts *bind.FilterOpts) (*scc.StateCommitmentChainStateBatchAppendedIterator, error) {
+func FilterStateBatchAppendedWithRetry(ctx context.Context, filterer *legacy_bindings.StateCommitmentChainFilterer, opts *bind.FilterOpts) (*legacy_bindings.StateCommitmentChainStateBatchAppendedIterator, error) {
 	for {
 		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
 		opts.Context = ctxt

--- a/indexer/services/l1/query.go
+++ b/indexer/services/l1/query.go
@@ -3,14 +3,14 @@ package l1
 import (
 	"context"
-	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum-optimism/optimism/indexer/services/l1/bridge"
+	legacy_bindings "github.com/ethereum-optimism/optimism/op-bindings/legacy-bindings"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
-func QueryStateBatches(filterer *scc.StateCommitmentChainFilterer, startHeight, endHeight uint64, ctx context.Context) (map[common.Hash][]db.StateBatch, error) {
+func QueryStateBatches(filterer *legacy_bindings.StateCommitmentChainFilterer, startHeight, endHeight uint64, ctx context.Context) (map[common.Hash][]db.StateBatch, error) {
 	batches := make(map[common.Hash][]db.StateBatch)
 	iter, err := bridge.FilterStateBatchAppendedWithRetry(ctx, filterer, &bind.FilterOpts{

--- a/indexer/services/l1/service.go
+++ b/indexer/services/l1/service.go
@@ -11,10 +11,10 @@ import (
 	"sync/atomic"
 	"time"
-	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/indexer/metrics"
 	"github.com/ethereum-optimism/optimism/indexer/services"
 	"github.com/ethereum-optimism/optimism/indexer/services/query"
+	legacy_bindings "github.com/ethereum-optimism/optimism/op-bindings/legacy-bindings"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/ethereum-optimism/optimism/indexer/server"
@@ -68,7 +68,7 @@ type Service struct {
 	bridges        map[string]bridge.Bridge
 	portal         *bridge.Portal
-	batchScanner   *scc.StateCommitmentChainFilterer
+	batchScanner   *legacy_bindings.StateCommitmentChainFilterer
 	latestHeader   uint64
 	headerSelector *ConfirmedHeaderSelector
 	l1Client       *ethclient.Client
@@ -108,7 +108,7 @@ func NewService(cfg ServiceConfig) (*Service, error) {
 	}
 	var portal *bridge.Portal
-	var batchScanner *scc.StateCommitmentChainFilterer
+	var batchScanner *legacy_bindings.StateCommitmentChainFilterer
 	if cfg.Bedrock {
 		portal = bridge.NewPortal(cfg.AddressManager)
 	} else {

--- a/op-bindings/bindings/disputegamefactory.go
+++ b/op-bindings/bindings/disputegamefactory.go
--- a/op-bindings/bindings/registry.go
+++ b/op-bindings/bindings/registry.go
@@ -2,15 +2,20 @@ package bindings
 import (
 	"fmt"
+	"strings"
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 	"github.com/ethereum/go-ethereum/common"
 )
+// layouts respresents the set of storage layouts. It is populated in an init function.
 var layouts = make(map[string]*solc.StorageLayout)
+// deployedBytecodes represents the set of deployed bytecodes. It is populated
+// in an init function.
 var deployedBytecodes = make(map[string]string)
+// GetStorageLayout returns the storage layout of a contract by name.
 func GetStorageLayout(name string) (*solc.StorageLayout, error) {
 	layout := layouts[name]
 	if layout == nil {
@@ -19,11 +24,36 @@ func GetStorageLayout(name string) (*solc.StorageLayout, error) {
 	return layout, nil
 }
+// GetDeployedBytecode returns the deployed bytecode of a contract by name.
 func GetDeployedBytecode(name string) ([]byte, error) {
 	bc := deployedBytecodes[name]
 	if bc == "" {
 		return nil, fmt.Errorf("%s: deployed bytecode not found", name)
 	}
+	if !isHex(bc) {
+		return nil, fmt.Errorf("%s: invalid deployed bytecode", name)
+	}
 	return common.FromHex(bc), nil
 }
+// isHexCharacter returns bool of c being a valid hexadecimal.
+func isHexCharacter(c byte) bool {
+	return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')
+}
+// isHex validates whether each byte is valid hexadecimal string.
+func isHex(str string) bool {
+	if len(str)%2 != 0 {
+		return false
+	}
+	str = strings.TrimPrefix(str, "0x")
+	for _, c := range []byte(str) {
+		if !isHexCharacter(c) {
+			return false
+		}
+	}
+	return true
+}
--- a/op-bindings/predeploys/addresses.go
+++ b/op-bindings/predeploys/addresses.go
@@ -46,6 +46,26 @@ var (
 	Predeploys = make(map[string]*common.Address)
 )
+// IsProxied returns true for predeploys that will sit behind a proxy contract
+func IsProxied(predeployAddr common.Address) bool {
+	switch predeployAddr {
+	case LegacyERC20ETHAddr:
+	case WETH9Addr:
+	case GovernanceTokenAddr:
+	case ProxyAdminAddr:
+	default:
+		return true
+	}
+	return false
+}
+// IsDeprecated returns true for predeploys we should skip in post-bedrock genesis generation
+func IsDeprecated(predeployAddr common.Address) bool {
+	// TODO: confirm if we can safely add the remaining deprecated predeploys here
+	// (see https://github.com/ethereum-optimism/optimism/blob/develop/specs/predeploys.md#overview)
+	return predeployAddr == LegacyERC20ETHAddr
+}
 func init() {
 	Predeploys["L2ToL1MessagePasser"] = &L2ToL1MessagePasserAddr
 	Predeploys["DeployerWhitelist"] = &DeployerWhitelistAddr

--- a/op-chain-ops/genesis/config.go
+++ b/op-chain-ops/genesis/config.go
@@ -113,6 +113,8 @@ type DeployConfig struct {
 	GasPriceOracleOverhead uint64 `json:"gasPriceOracleOverhead"`
 	// The initial value of the gas scalar
 	GasPriceOracleScalar uint64 `json:"gasPriceOracleScalar"`
+	// Whether or not include governance token predeploy
+	EnableGovernance bool `json:"enableGovernance"`
 	// The ERC20 symbol of the GovernanceToken
 	GovernanceTokenSymbol string `json:"governanceTokenSymbol"`
 	// The ERC20 name of the GovernanceToken
@@ -240,14 +242,16 @@ func (d *DeployConfig) Check() error {
 	if d.L2GenesisBlockBaseFeePerGas == nil {
 		return fmt.Errorf("%w: L2 genesis block base fee per gas cannot be nil", ErrInvalidDeployConfig)
 	}
-	if d.GovernanceTokenName == "" {
+	if d.EnableGovernance {
-		return fmt.Errorf("%w: GovernanceToken.name cannot be empty", ErrInvalidDeployConfig)
+		if d.GovernanceTokenName == "" {
-	}
+			return fmt.Errorf("%w: GovernanceToken.name cannot be empty", ErrInvalidDeployConfig)
-	if d.GovernanceTokenSymbol == "" {
+		}
-		return fmt.Errorf("%w: GovernanceToken.symbol cannot be empty", ErrInvalidDeployConfig)
+		if d.GovernanceTokenSymbol == "" {
-	}
+			return fmt.Errorf("%w: GovernanceToken.symbol cannot be empty", ErrInvalidDeployConfig)
-	if d.GovernanceTokenOwner == (common.Address{}) {
+		}
-		return fmt.Errorf("%w: GovernanceToken owner cannot be address(0)", ErrInvalidDeployConfig)
+		if d.GovernanceTokenOwner == (common.Address{}) {
+			return fmt.Errorf("%w: GovernanceToken owner cannot be address(0)", ErrInvalidDeployConfig)
+		}
 	}
 	return nil
 }
@@ -492,10 +496,12 @@ func NewL2StorageConfig(config *DeployConfig, block *types.Block) (state.Storage
 		"symbol":   "WETH",
 		"decimals": 18,
 	}
-	storage["GovernanceToken"] = state.StorageValues{
+	if config.EnableGovernance {
-		"_name":   config.GovernanceTokenName,
+		storage["GovernanceToken"] = state.StorageValues{
-		"_symbol": config.GovernanceTokenSymbol,
+			"_name":   config.GovernanceTokenName,
-		"_owner":  config.GovernanceTokenOwner,
+			"_symbol": config.GovernanceTokenSymbol,
+			"_owner":  config.GovernanceTokenOwner,
+		}
 	}
 	storage["ProxyAdmin"] = state.StorageValues{
 		"_owner": config.ProxyAdminOwner,

--- a/op-chain-ops/genesis/layer_two.go
+++ b/op-chain-ops/genesis/layer_two.go
 package genesis
 import (
-	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
+	"errors"
-	"github.com/ethereum/go-ethereum/core/types"
+	"fmt"
+	"math/big"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/immutables"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
 )
 // BuildL2DeveloperGenesis will build the developer Optimism Genesis
@@ -46,3 +55,90 @@ func BuildL2DeveloperGenesis(config *DeployConfig, l1StartBlock *types.Block) (*
 	return db.Genesis(), nil
 }
+// BuildL2MainnetGenesis will build an L2 Genesis suitable for a Superchain mainnet that does not
+// require a pre-bedrock migration & supports optional governance token predeploy. Details:
+//
+//   - Creates proxies for predeploys in the address space:
+//     [0x4200000000000000000000000000000000000000, 0x4200000000000000000000000000000000000800)
+//
+//   - All predeploy proxies owned by the ProxyAdmin
+//
+//   - Predeploys as per the spec except for no LegacyERC20ETH predeploy at
+//     0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000
+//
+//   - optional governance token at 0x4200000000000000000000000000000000000042 if
+//     config.EnableGovernance is true (& otherwise a no-impl proxy remains at this address)
+//
+//   - no accounts are pre-funded
+func BuildL2MainnetGenesis(config *DeployConfig, l1StartBlock *types.Block) (*core.Genesis, error) {
+	genspec, err := NewL2Genesis(config, l1StartBlock)
+	if err != nil {
+		return nil, err
+	}
+	db := state.NewMemoryStateDB(genspec)
+	storage, err := NewL2StorageConfig(config, l1StartBlock)
+	if err != nil {
+		return nil, err
+	}
+	immutable, err := NewL2ImmutableConfig(config, l1StartBlock)
+	if err != nil {
+		return nil, err
+	}
+	// Set up the proxies
+	depBytecode, err := bindings.GetDeployedBytecode("Proxy")
+	if err != nil {
+		return nil, err
+	}
+	if len(depBytecode) == 0 {
+		return nil, errors.New("Proxy has empty bytecode")
+	}
+	for i := uint64(0); i <= 2048; i++ {
+		bigAddr := new(big.Int).Or(bigL2PredeployNamespace, new(big.Int).SetUint64(i))
+		addr := common.BigToAddress(bigAddr)
+		db.CreateAccount(addr)
+		db.SetCode(addr, depBytecode)
+		db.SetState(addr, AdminSlot, predeploys.ProxyAdminAddr.Hash())
+	}
+	// Set up the implementations
+	deployResults, err := immutables.BuildOptimism(immutable)
+	if err != nil {
+		return nil, err
+	}
+	for name, predeploy := range predeploys.Predeploys {
+		addr := *predeploy
+		if predeploys.IsDeprecated(addr) {
+			continue
+		}
+		if addr == predeploys.GovernanceTokenAddr && !config.EnableGovernance {
+			// there is no governance token configured, so skip the governance token predeploy
+			log.Warn("Governance is not enabled, skipping governance token predeploy.")
+			continue
+		}
+		codeAddr := addr
+		if predeploys.IsProxied(addr) {
+			codeAddr, err = AddressToCodeNamespace(addr)
+			if err != nil {
+				return nil, fmt.Errorf("error converting to code namespace: %w", err)
+			}
+			db.CreateAccount(codeAddr)
+			db.SetState(addr, ImplementationSlot, codeAddr.Hash())
+		} else {
+			db.DeleteState(addr, AdminSlot)
+		}
+		if err := setupPredeploy(db, deployResults, storage, name, addr, codeAddr); err != nil {
+			return nil, err
+		}
+		code := db.GetCode(codeAddr)
+		if len(code) == 0 {
+			return nil, fmt.Errorf("code not set for %s", name)
+		}
+	}
+	return db.Genesis(), nil
+}
--- a/op-chain-ops/genesis/layer_two_test.go
+++ b/op-chain-ops/genesis/layer_two_test.go
@@ -8,17 +8,16 @@ import (
 	"os"
 	"testing"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/stretchr/testify/require"
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
-	"github.com/stretchr/testify/require"
 )
 var writeFile bool
@@ -46,14 +45,14 @@ func TestBuildL2DeveloperGenesis(t *testing.T) {
 	require.Nil(t, err)
 	require.NotNil(t, gen)
-	depB, err := bindings.GetDeployedBytecode("Proxy")
+	proxyBytecode, err := bindings.GetDeployedBytecode("Proxy")
 	require.NoError(t, err)
 	for name, address := range predeploys.Predeploys {
 		addr := *address
 		account, ok := gen.Alloc[addr]
-		require.Equal(t, ok, true)
+		require.Equal(t, true, ok)
 		require.Greater(t, len(account.Code), 0)
 		if name == "GovernanceToken" || name == "LegacyERC20ETH" || name == "ProxyAdmin" || name == "WETH9" {
@@ -61,9 +60,9 @@ func TestBuildL2DeveloperGenesis(t *testing.T) {
 		}
 		adminSlot, ok := account.Storage[genesis.AdminSlot]
-		require.Equal(t, ok, true)
+		require.Equal(t, true, ok, name)
-		require.Equal(t, adminSlot, predeploys.ProxyAdminAddr.Hash())
+		require.Equal(t, predeploys.ProxyAdminAddr.Hash(), adminSlot)
-		require.Equal(t, account.Code, depB)
+		require.Equal(t, proxyBytecode, account.Code)
 	}
 	require.Equal(t, 2343, len(gen.Alloc))
@@ -94,3 +93,67 @@ func TestBuildL2DeveloperGenesisDevAccountsFunding(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, 2321, len(gen.Alloc))
 }
+// Tests the BuildL2MainnetGenesis factory. enableGovernance is used to override enableGovernance
+// config option. When false, the test confirms the governance token predeploy address instead
+// holds a proxy contract.
+func testBuildL2Genesis(t *testing.T, enableGovernance bool) {
+	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
+	require.Nil(t, err)
+	config.EnableGovernance = enableGovernance
+	backend := backends.NewSimulatedBackend(
+		core.GenesisAlloc{
+			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
+		},
+		15000000,
+	)
+	block, err := backend.BlockByNumber(context.Background(), common.Big0)
+	require.NoError(t, err)
+	gen, err := genesis.BuildL2MainnetGenesis(config, block)
+	require.Nil(t, err)
+	require.NotNil(t, gen)
+	proxyBytecode, err := bindings.GetDeployedBytecode("Proxy")
+	require.NoError(t, err)
+	for name, predeploy := range predeploys.Predeploys {
+		addr := *predeploy
+		account, ok := gen.Alloc[addr]
+		if predeploys.IsDeprecated(addr) && !predeploys.IsProxied(addr) {
+			// deprecated, non-proxied predeploys should have no account
+			require.Equal(t, false, ok, name)
+			continue
+		}
+		require.Equal(t, true, ok, name)
+		require.Greater(t, len(account.Code), 0)
+		adminSlot, ok := account.Storage[genesis.AdminSlot]
+		isProxy := predeploys.IsProxied(addr) ||
+			(!enableGovernance && addr == predeploys.GovernanceTokenAddr)
+		if isProxy {
+			require.Equal(t, true, ok, name)
+			require.Equal(t, predeploys.ProxyAdminAddr.Hash(), adminSlot)
+			require.Equal(t, proxyBytecode, account.Code)
+		} else {
+			require.Equal(t, false, ok, name)
+			require.NotEqual(t, proxyBytecode, account.Code, name)
+		}
+	}
+	require.Equal(t, 2063, len(gen.Alloc))
+	if writeFile {
+		file, _ := json.MarshalIndent(gen, "", " ")
+		_ = os.WriteFile("genesis.json", file, 0644)
+	}
+}
+func TestBuildL2MainnetGenesis(t *testing.T) {
+	testBuildL2Genesis(t, true)
+}
+func TestBuildL2MainnetNoGovernanceGenesis(t *testing.T) {
+	testBuildL2Genesis(t, false)
+}
--- a/op-chain-ops/genesis/testdata/test-deploy-config-devnet-l1.json
+++ b/op-chain-ops/genesis/testdata/test-deploy-config-devnet-l1.json
@@ -35,5 +35,10 @@
  "l1CrossDomainMessengerProxy": "0xff000000000000000000000000000000000000dd",
  "deploymentWaitConfirmations": 1,
-  "fundDevAccounts": true
+  "fundDevAccounts": true,
+  "enableGovernance": true,
+  "governanceTokenSymbol": "OP",
+  "governanceTokenName": "Optimism",
+  "governanceTokenOwner": "0x0000000000000000000000000000000000000333"
 }
--- a/op-chain-ops/genesis/testdata/test-deploy-config-full.json
+++ b/op-chain-ops/genesis/testdata/test-deploy-config-full.json
@@ -54,6 +54,7 @@
  "proxyAdminOwner": "0x0000000000000000000000000000000000000222",
  "gasPriceOracleOverhead": 2100,
  "gasPriceOracleScalar": 1000000,
+  "enableGovernance": true,
  "governanceTokenSymbol": "OP",
  "governanceTokenName": "Optimism",
  "governanceTokenOwner": "0x0000000000000000000000000000000000000333",

--- a/op-chain-ops/state/memory_db.go
+++ b/op-chain-ops/state/memory_db.go
@@ -226,6 +226,15 @@ func (db *MemoryStateDB) SetState(addr common.Address, key, value common.Hash) {
 	db.genesis.Alloc[addr] = account
 }
+func (db *MemoryStateDB) DeleteState(addr common.Address, key common.Hash) {
+	account, ok := db.genesis.Alloc[addr]
+	if !ok {
+		panic(fmt.Sprintf("%s not in state", addr))
+	}
+	delete(account.Storage, key)
+	db.genesis.Alloc[addr] = account
+}
 func (db *MemoryStateDB) Suicide(common.Address) bool {
 	panic("Suicide unimplemented")
 }

--- a/op-e2e/system_test.go
+++ b/op-e2e/system_test.go
@@ -816,7 +816,7 @@ func TestSystemDenseTopology(t *testing.T) {
 		params, err := p2p.GetPeerScoreParams("light", 2)
 		require.NoError(t, err)
 		node.P2P = &p2p.Config{
-			PeerScoring:    params,
+			PeerScoring:    &params,
 			BanningEnabled: false,
 		}
 	}

--- a/op-node/p2p/cli/load_config.go
+++ b/op-node/p2p/cli/load_config.go
@@ -98,7 +98,7 @@ func loadTopicScoringParams(conf *p2p.Config, ctx *cli.Context, blockTime uint64
 		if err != nil {
 			return err
 		}
-		conf.TopicScoring = topicScoreParams
+		conf.TopicScoring = &topicScoreParams
 	}
 	return nil
@@ -114,7 +114,7 @@ func loadPeerScoringParams(conf *p2p.Config, ctx *cli.Context, blockTime uint64)
 		if err != nil {
 			return err
 		}
-		conf.PeerScoring = peerScoreParams
+		conf.PeerScoring = &peerScoreParams
 	}
 	return nil

--- a/op-node/p2p/config.go
+++ b/op-node/p2p/config.go
@@ -63,8 +63,8 @@ type Config struct {
 	AltSync bool
 	// Pubsub Scoring Parameters
-	PeerScoring  pubsub.PeerScoreParams
+	PeerScoring  *pubsub.PeerScoreParams
-	TopicScoring pubsub.TopicScoreParams
+	TopicScoring *pubsub.TopicScoreParams
 	// Whether to ban peers based on their [PeerScoring] score. Should be negative.
 	BanningEnabled bool
@@ -135,7 +135,7 @@ func (conf *Config) Disabled() bool {
 }
 func (conf *Config) PeerScoringParams() *pubsub.PeerScoreParams {
-	return &conf.PeerScoring
+	return conf.PeerScoring
 }
 func (conf *Config) BanPeers() bool {
@@ -151,7 +151,7 @@ func (conf *Config) BanDuration() time.Duration {
 }
 func (conf *Config) TopicScoringParams() *pubsub.TopicScoreParams {
-	return &conf.TopicScoring
+	return conf.TopicScoring
 }
 func (conf *Config) ReqRespSyncEnabled() bool {

--- a/op-node/p2p/gossip.go
+++ b/op-node/p2p/gossip.go
@@ -443,10 +443,7 @@ func JoinGossip(p2pCtx context.Context, self peer.ID, topicScoreParams *pubsub.T
 	}
 	go LogTopicEvents(p2pCtx, log.New("topic", "blocks"), blocksTopicEvents)
-	// A [TimeInMeshQuantum] value of 0 means the topic score is disabled.
+	if topicScoreParams != nil {
-	// If we passed a topicScoreParams with [TimeInMeshQuantum] set to 0,
-	// libp2p errors since the params will be rejected.
-	if topicScoreParams != nil && topicScoreParams.TimeInMeshQuantum != 0 {
 		if err = blocksTopic.SetScoreParams(topicScoreParams); err != nil {
 			return nil, fmt.Errorf("failed to set topic score params: %w", err)
 		}

--- a/op-node/p2p/host.go
+++ b/op-node/p2p/host.go
@@ -146,7 +146,15 @@ func (conf *Config) Host(log log.Logger, reporter metrics.Reporter, metrics Host
 	}
 	peerScoreParams := conf.PeerScoringParams()
-	ps, err := store.NewExtendedPeerstore(context.Background(), log, clock.SystemClock, basePs, conf.Store, peerScoreParams.RetainScore)
+	var scoreRetention time.Duration
+	if peerScoreParams != nil {
+		// Use the same retention period as gossip will if available
+		scoreRetention = peerScoreParams.RetainScore
+	} else {
+		// Disable score GC if peer scoring is disabled
+		scoreRetention = 0
+	}
+	ps, err := store.NewExtendedPeerstore(context.Background(), log, clock.SystemClock, basePs, conf.Store, scoreRetention)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open extended peerstore: %w", err)
 	}

--- a/op-node/p2p/peer_scores.go
+++ b/op-node/p2p/peer_scores.go
@@ -12,14 +12,13 @@ func ConfigurePeerScoring(gossipConf GossipSetupConfigurables, scorer Scorer, lo
 	peerScoreParams := gossipConf.PeerScoringParams()
 	peerScoreThresholds := NewPeerScoreThresholds()
 	opts := []pubsub.Option{}
-	// Check the app specific score since libp2p doesn't export it's [validate] function :/
+	if peerScoreParams != nil {
-	if peerScoreParams != nil && peerScoreParams.AppSpecificScore != nil {
 		opts = []pubsub.Option{
 			pubsub.WithPeerScore(peerScoreParams, &peerScoreThresholds),
 			pubsub.WithPeerScoreInspect(scorer.SnapshotHook(), peerScoreInspectFrequency),
 		}
 	} else {
-		log.Warn("Proceeding with no peer scoring...\nMissing AppSpecificScore in peer scoring params")
+		log.Info("Peer scoring disabled")
 	}
 	return opts
 }
--- a/op-node/p2p/peer_scores_test.go
+++ b/op-node/p2p/peer_scores_test.go
@@ -102,7 +102,7 @@ func newGossipSubs(testSuite *PeerScoresTestSuite, ctx context.Context, hosts []
 			&rollup.Config{L2ChainID: big.NewInt(123)},
 			extPeerStore, testSuite.mockMetricer, logger)
 		opts = append(opts, ConfigurePeerScoring(&Config{
-			PeerScoring: pubsub.PeerScoreParams{
+			PeerScoring: &pubsub.PeerScoreParams{
 				AppSpecificScore: func(p peer.ID) float64 {
 					if p == hosts[0].ID() {
 						return -1000

--- a/op-node/rollup/types.go
+++ b/op-node/rollup/types.go
@@ -142,7 +142,7 @@ func (cfg *Config) CheckL1ChainID(ctx context.Context, client L1Client) error {
 		return err
 	}
 	if cfg.L1ChainID.Cmp(id) != 0 {
-		return fmt.Errorf("incorrect L1 RPC chain id %d, expected %d", cfg.L1ChainID, id)
+		return fmt.Errorf("incorrect L1 RPC chain id %d, expected %d", id, cfg.L1ChainID)
 	}
 	return nil
 }
@@ -154,7 +154,7 @@ func (cfg *Config) CheckL1GenesisBlockHash(ctx context.Context, client L1Client)
 		return err
 	}
 	if l1GenesisBlockRef.Hash != cfg.Genesis.L1.Hash {
-		return fmt.Errorf("incorrect L1 genesis block hash %d, expected %d", cfg.Genesis.L1.Hash, l1GenesisBlockRef.Hash)
+		return fmt.Errorf("incorrect L1 genesis block hash %s, expected %s", l1GenesisBlockRef.Hash, cfg.Genesis.L1.Hash)
 	}
 	return nil
 }
@@ -171,7 +171,7 @@ func (cfg *Config) CheckL2ChainID(ctx context.Context, client L2Client) error {
 		return err
 	}
 	if cfg.L2ChainID.Cmp(id) != 0 {
-		return fmt.Errorf("incorrect L2 RPC chain id, expected from config %d, obtained from client %d", cfg.L2ChainID, id)
+		return fmt.Errorf("incorrect L2 RPC chain id %d, expected %d", id, cfg.L2ChainID)
 	}
 	return nil
 }
@@ -183,7 +183,7 @@ func (cfg *Config) CheckL2GenesisBlockHash(ctx context.Context, client L2Client)
 		return err
 	}
 	if l2GenesisBlockRef.Hash != cfg.Genesis.L2.Hash {
-		return fmt.Errorf("incorrect L2 genesis block hash %d, expected %d", cfg.Genesis.L2.Hash, l2GenesisBlockRef.Hash)
+		return fmt.Errorf("incorrect L2 genesis block hash %s, expected %s", l2GenesisBlockRef.Hash, cfg.Genesis.L2.Hash)
 	}
 	return nil
 }

--- a/op-service/Makefile
+++ b/op-service/Makefile
@@ -2,7 +2,7 @@ test:
 	go test -v ./...
 lint:
-	golangci-lint run -E asciicheck,goimports,misspell ./...
+	golangci-lint run -E goimports,sqlclosecheck,bodyclose,asciicheck,misspell,errorlint -e "errors.As" -e "errors.Is" ./...
 generate-mocks:
 	go generate ./...

--- a/op-service/client/retry.go
+++ b/op-service/client/retry.go
@@ -6,6 +6,7 @@ import (
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/hashicorp/go-multierror"
 	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-service/backoff"
@@ -53,12 +54,62 @@ func (b *retryingClient) CallContext(ctx context.Context, result any, method str
 	})
 }
-func (b *retryingClient) BatchCallContext(ctx context.Context, batch []rpc.BatchElem) error {
+// pendingReq combines BatchElem information with the index of this request in the original []rpc.BatchElem
+type pendingReq struct {
+	// req is a copy of the BatchElem individual request to make.
+	// It never has Result or Error set as it gets copied again as part of being passed to the underlying client.
+	req rpc.BatchElem
+	// idx tracks the index of the original BatchElem in the supplied input array
+	// This can then be used to set the result on the original input
+	idx int
+}
+func (b *retryingClient) BatchCallContext(ctx context.Context, input []rpc.BatchElem) error {
+	// Add all BatchElem to the initial pending set
+	// Each time we retry, we'll remove successful BatchElem for this list so we only retry ones that fail.
+	pending := make([]*pendingReq, len(input))
+	for i, req := range input {
+		pending[i] = &pendingReq{
+			req: req,
+			idx: i,
+		}
+	}
 	return backoff.DoCtx(ctx, b.retryAttempts, b.strategy, func() error {
 		cCtx, cancel := context.WithTimeout(ctx, 20*time.Second)
 		defer cancel()
+		batch := make([]rpc.BatchElem, len(pending))
+		for i, req := range pending {
+			batch[i] = req.req
+		}
 		err := b.c.BatchCallContext(cCtx, batch)
-		return err
+		if err != nil {
+			// Whole call failed, retry all pending elems again
+			return err
+		}
+		var failed []*pendingReq
+		var combinedErr error
+		for i, elem := range batch {
+			req := pending[i]
+			idx := req.idx // Index into input of the original BatchElem
+			// Set the result on the original batch to pass back to the caller in case we stop retrying
+			input[idx].Error = elem.Error
+			input[idx].Result = elem.Result
+			// If the individual request failed, add it to the list to retry
+			if elem.Error != nil {
+				// Need to retry this request
+				failed = append(failed, req)
+				combinedErr = multierror.Append(elem.Error, combinedErr)
+			}
+		}
+		if len(failed) > 0 {
+			pending = failed
+			return combinedErr
+		}
+		return nil
 	})
 }

--- a/op-service/client/retry_test.go
+++ b/op-service/client/retry_test.go
@@ -32,7 +32,11 @@ func (m *MockRPC) CallContext(ctx context.Context, result any, method string, ar
 func (m *MockRPC) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
 	out := m.Mock.MethodCalled("BatchCallContext", ctx, b)
-	return *out[0].(*error)
+	err, ok := out[0].(*error)
+	if ok {
+		return *err
+	}
+	return nil
 }
 func (m *MockRPC) EthSubscribe(ctx context.Context, channel any, args ...any) (ethereum.Subscription, error) {
@@ -48,6 +52,12 @@ func (m *MockRPC) ExpectBatchCallContext(err error, b []rpc.BatchElem) {
 	m.On("BatchCallContext", mock.Anything, b).Return(&err)
 }
+func (m *MockRPC) OnBatchCallContext(err error, b []rpc.BatchElem, action func(callBatches []rpc.BatchElem)) {
+	m.On("BatchCallContext", mock.Anything, b).Return(err).Run(func(args mock.Arguments) {
+		action(args[1].([]rpc.BatchElem))
+	})
+}
 func (m *MockRPC) ExpectEthSubscribe(sub ethereum.Subscription, err error, channel any, args ...any) {
 	m.On("EthSubscribe", mock.Anything, channel, args).Return(&sub, &err)
 }
@@ -84,7 +94,7 @@ func TestClient_BackoffClient_CallContext(t *testing.T) {
 func TestClient_BackoffClient_CallContext_WithRetries(t *testing.T) {
 	mockRpc := &MockRPC{}
 	mockRpc.ExpectCallContext(errors.New("foo"), nil, "foo", "bar")
-	backoffClient := client.NewRetryingClient(mockRpc, 2)
+	backoffClient := client.NewRetryingClient(mockRpc, 2, backoff.Fixed(0))
 	err := backoffClient.CallContext(context.Background(), nil, "foo", "bar")
 	require.Error(t, err)
 	require.True(t, mockRpc.AssertNumberOfCalls(t, "CallContext", 2))
@@ -92,22 +102,79 @@ func TestClient_BackoffClient_CallContext_WithRetries(t *testing.T) {
 func TestClient_BackoffClient_BatchCallContext(t *testing.T) {
 	mockRpc := &MockRPC{}
-	mockRpc.ExpectBatchCallContext(nil, []rpc.BatchElem(nil))
+	mockRpc.ExpectBatchCallContext(nil, []rpc.BatchElem{})
 	backoffClient := client.NewRetryingClient(mockRpc, 1)
 	err := backoffClient.BatchCallContext(context.Background(), nil)
 	require.NoError(t, err)
-	require.True(t, mockRpc.AssertCalled(t, "BatchCallContext", mock.Anything, []rpc.BatchElem(nil)))
+	require.True(t, mockRpc.AssertCalled(t, "BatchCallContext", mock.Anything, []rpc.BatchElem{}))
 }
 func TestClient_BackoffClient_BatchCallContext_WithRetries(t *testing.T) {
 	mockRpc := &MockRPC{}
-	mockRpc.ExpectBatchCallContext(errors.New("foo"), []rpc.BatchElem(nil))
+	mockRpc.ExpectBatchCallContext(errors.New("foo"), []rpc.BatchElem{})
-	backoffClient := client.NewRetryingClient(mockRpc, 2)
+	backoffClient := client.NewRetryingClient(mockRpc, 2, backoff.Fixed(0))
 	err := backoffClient.BatchCallContext(context.Background(), nil)
 	require.Error(t, err)
 	require.True(t, mockRpc.AssertNumberOfCalls(t, "BatchCallContext", 2))
 }
+func TestClient_BackoffClient_BatchCallContext_WithPartialRetries(t *testing.T) {
+	batches := []rpc.BatchElem{
+		{Method: "0"},
+		{Method: "1"},
+		{Method: "2"},
+	}
+	mockRpc := &MockRPC{}
+	mockRpc.OnBatchCallContext(nil, batches, func(batch []rpc.BatchElem) {
+		batch[0].Result = batch[0].Method
+		batch[1].Error = errors.New("boom")
+		batch[2].Error = errors.New("boom")
+	})
+	mockRpc.OnBatchCallContext(nil, []rpc.BatchElem{batches[1], batches[2]}, func(batch []rpc.BatchElem) {
+		batch[0].Error = errors.New("boom again")
+		batch[1].Result = batch[1].Method
+	})
+	backoffClient := client.NewRetryingClient(mockRpc, 2, backoff.Fixed(0))
+	err := backoffClient.BatchCallContext(context.Background(), batches)
+	require.Error(t, err)
+	require.True(t, mockRpc.AssertNumberOfCalls(t, "BatchCallContext", 2))
+	// Check our original batches got updated correctly
+	require.Equal(t, rpc.BatchElem{Method: "0", Result: "0"}, batches[0])
+	require.Equal(t, rpc.BatchElem{Method: "1", Result: nil, Error: errors.New("boom again")}, batches[1])
+	require.Equal(t, rpc.BatchElem{Method: "2", Result: "2"}, batches[2])
+}
+func TestClient_BackoffClient_BatchCallContext_WithPartialRetriesUntilSuccess(t *testing.T) {
+	batches := []rpc.BatchElem{
+		{Method: "0"},
+		{Method: "1"},
+		{Method: "2"},
+	}
+	mockRpc := &MockRPC{}
+	mockRpc.OnBatchCallContext(nil, batches, func(batch []rpc.BatchElem) {
+		batch[0].Result = batch[0].Method
+		batch[1].Error = errors.New("boom")
+		batch[2].Error = errors.New("boom")
+	})
+	mockRpc.OnBatchCallContext(nil, []rpc.BatchElem{batches[1], batches[2]}, func(batch []rpc.BatchElem) {
+		batch[0].Error = errors.New("boom again")
+		batch[1].Result = batch[1].Method
+	})
+	mockRpc.OnBatchCallContext(nil, []rpc.BatchElem{batches[1]}, func(batch []rpc.BatchElem) {
+		batch[0].Result = batch[0].Method
+	})
+	backoffClient := client.NewRetryingClient(mockRpc, 4, backoff.Fixed(0))
+	err := backoffClient.BatchCallContext(context.Background(), batches)
+	require.NoError(t, err)
+	require.True(t, mockRpc.AssertNumberOfCalls(t, "BatchCallContext", 3))
+	// Check our original batches got updated correctly
+	require.Equal(t, rpc.BatchElem{Method: "0", Result: "0"}, batches[0])
+	require.Equal(t, rpc.BatchElem{Method: "1", Result: "1"}, batches[1])
+	require.Equal(t, rpc.BatchElem{Method: "2", Result: "2"}, batches[2])
+}
 func TestClient_BackoffClient_EthSubscribe(t *testing.T) {
 	mockRpc := &MockRPC{}
 	mockRpc.ExpectEthSubscribe(ethereum.Subscription(nil), nil, nil, "foo", "bar")
@@ -120,7 +187,7 @@ func TestClient_BackoffClient_EthSubscribe(t *testing.T) {
 func TestClient_BackoffClient_EthSubscribe_WithRetries(t *testing.T) {
 	mockRpc := &MockRPC{}
 	mockRpc.ExpectEthSubscribe(ethereum.Subscription(nil), errors.New("foo"), nil, "foo", "bar")
-	backoffClient := client.NewRetryingClient(mockRpc, 2)
+	backoffClient := client.NewRetryingClient(mockRpc, 2, backoff.Fixed(0))
 	_, err := backoffClient.EthSubscribe(context.Background(), nil, "foo", "bar")
 	require.Error(t, err)
 	require.True(t, mockRpc.AssertNumberOfCalls(t, "EthSubscribe", 2))

--- a/packages/chain-mon/src/wd-mon/service.ts
+++ b/packages/chain-mon/src/wd-mon/service.ts
@@ -191,16 +191,14 @@ export class WithdrawalMonitor extends BaseServiceV2<Options, Metrics, State> {
        await this.state.messenger.contracts.l2.BedrockMessagePasser.sentMessages(
          proofEvent.args.withdrawalHash
        )
-      const provenAt = `${
+      const block = await proofEvent.getBlock()
-        (dateformat(
+      const now = new Date(block.timestamp * 1000)
-          new Date(
+      const dateString = dateformat(
-            (await this.options.l1RpcProvider.getBlock(proofEvent.blockHash))
+        now,
-              .timestamp * 1000
-          )
-        ),
        'mmmm dS, yyyy, h:MM:ss TT',
-        true)
+        true // use UTC time
-      } UTC`
+      )
+      const provenAt = `${dateString} UTC`
      if (exists) {
        this.metrics.withdrawalsValidated.inc()
        this.logger.info(`valid withdrawal`, {

--- a/packages/contracts-bedrock/.gas-snapshot
+++ b/packages/contracts-bedrock/.gas-snapshot
@@ -27,11 +27,11 @@ CrossDomainOwnable_Test:test_onlyOwner_notOwner_reverts() (gas: 10597)
 CrossDomainOwnable_Test:test_onlyOwner_succeeds() (gas: 34883)
 DeployerWhitelist_Test:test_owner_succeeds() (gas: 7582)
 DeployerWhitelist_Test:test_storageSlots_succeeds() (gas: 33395)
-DisputeGameFactory_Test:test_owner_succeeds() (gas: 7582)
+DisputeGameFactory_Test:test_owner_succeeds() (gas: 7627)
-DisputeGameFactory_Test:test_setImplementation_notOwner_reverts() (gas: 11191)
+DisputeGameFactory_Test:test_setImplementation_notOwner_reverts() (gas: 11077)
-DisputeGameFactory_Test:test_setImplementation_succeeds() (gas: 38765)
+DisputeGameFactory_Test:test_setImplementation_succeeds() (gas: 38320)
 DisputeGameFactory_Test:test_transferOwnership_notOwner_reverts() (gas: 10979)
-DisputeGameFactory_Test:test_transferOwnership_succeeds() (gas: 13180)
+DisputeGameFactory_Test:test_transferOwnership_succeeds() (gas: 13225)
 FeeVault_Test:test_constructor_succeeds() (gas: 18185)
 GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_0() (gas: 352135)
 GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_1() (gas: 2950342)

--- a/packages/contracts-bedrock/.storage-layout
+++ b/packages/contracts-bedrock/.storage-layout
@@ -253,11 +253,12 @@
 ➡ contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory
 =======================
-| Name         | Type                                            | Slot | Offset | Bytes | Contract                                                    |
+| Name            | Type                                       | Slot | Offset | Bytes | Contract                                                    |
-|--------------|-------------------------------------------------|------|--------|-------|-------------------------------------------------------------|
+|-----------------|--------------------------------------------|------|--------|-------|-------------------------------------------------------------|
-| _owner       | address                                         | 0    | 0      | 20    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| _owner          | address                                    | 0    | 0      | 20    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
-| gameImpls    | mapping(enum GameType => contract IDisputeGame) | 1    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| gameImpls       | mapping(GameType => contract IDisputeGame) | 1    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
-| disputeGames | mapping(Hash => contract IDisputeGame)          | 2    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| disputeGames    | mapping(Hash => contract IDisputeGame)     | 2    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| disputeGameList | contract IDisputeGame[]                    | 3    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
 =======================
 ➡ contracts/dispute/BondManager.sol:BondManager

--- a/packages/contracts-bedrock/contracts/dispute/BondManager.sol
+++ b/packages/contracts-bedrock/contracts/dispute/BondManager.sol
@@ -83,7 +83,7 @@ contract BondManager is IBondManager {
        IDisputeGame caller = IDisputeGame(msg.sender);
        IDisputeGame game = DISPUTE_GAME_FACTORY.games(
-            GameType.ATTESTATION,
+            GameTypes.ATTESTATION,
            caller.rootClaim(),
            caller.extraData()
        );
@@ -108,7 +108,7 @@ contract BondManager is IBondManager {
        IDisputeGame caller = IDisputeGame(msg.sender);
        IDisputeGame game = DISPUTE_GAME_FACTORY.games(
-            GameType.ATTESTATION,
+            GameTypes.ATTESTATION,
            caller.rootClaim(),
            caller.extraData()
        );

--- a/packages/contracts-bedrock/contracts/dispute/DisputeGameFactory.sol
+++ b/packages/contracts-bedrock/contracts/dispute/DisputeGameFactory.sol
@@ -32,6 +32,13 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
     */
    mapping(Hash => IDisputeGame) internal disputeGames;
+    /**
+     * @notice An append-only array of disputeGames that have been created.
+     * @dev This accessor is used by offchain game solvers to efficiently
+     *      track dispute games
+     */
+    IDisputeGame[] public disputeGameList;
    /**
     * @notice Constructs a new DisputeGameFactory contract.
     * @param _owner The owner of the contract.
@@ -40,6 +47,13 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
        transferOwnership(_owner);
    }
+    /**
+     * @inheritdoc IDisputeGameFactory
+     */
+    function gameCount() external view returns (uint256 _gameCount) {
+        _gameCount = disputeGameList.length;
+    }
    /**
     * @inheritdoc IDisputeGameFactory
     */
@@ -81,6 +95,7 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
        // Store the dispute game in the mapping & emit the `DisputeGameCreated` event.
        disputeGames[uuid] = proxy;
+        disputeGameList.push(proxy);
        emit DisputeGameCreated(address(proxy), gameType, rootClaim);
    }

--- a/packages/contracts-bedrock/contracts/dispute/interfaces/IDisputeGameFactory.sol
+++ b/packages/contracts-bedrock/contracts/dispute/interfaces/IDisputeGameFactory.sol
@@ -29,6 +29,12 @@ interface IDisputeGameFactory {
     */
    event ImplementationSet(address indexed impl, GameType indexed gameType);
+    /**
+     * @notice the total number of dispute games created by this factory.
+     * @return _gameCount The total number of dispute games created by this factory.
+     */
+    function gameCount() external view returns (uint256 _gameCount);
    /**
     * @notice `games` queries an internal a mapping that maps the hash of
     *         `gameType ++ rootClaim ++ extraData` to the deployed `DisputeGame` clone.

--- a/packages/contracts-bedrock/contracts/libraries/DisputeTypes.sol
+++ b/packages/contracts-bedrock/contracts/libraries/DisputeTypes.sol
@@ -57,6 +57,11 @@ type Clock is uint256;
 */
 type Position is uint256;
+/**
+ * @notice A `GameType` represents the type of game being played.
+ */
+type GameType is uint8;
 /**
 * @notice The current status of the dispute game.
 */
@@ -70,13 +75,22 @@ enum GameStatus {
 }
 /**
- * @notice The type of proof system being used.
+ * @title GameTypes
+ * @notice A library that defines the IDs of games that can be played.
 */
-enum GameType {
+library GameTypes {
-    // The game will use a `IDisputeGame` implementation that utilizes fault proofs.
+    /**
-    FAULT,
+     * @dev The game will use a `IDisputeGame` implementation that utilizes fault proofs.
-    // The game will use a `IDisputeGame` implementation that utilizes validity proofs.
+     */
-    VALIDITY,
+    GameType internal constant FAULT = GameType.wrap(0);
-    // The game will use a `IDisputeGame` implementation that utilizes attestation proofs.
-    ATTESTATION
+    /**
+     * @dev The game will use a `IDisputeGame` implementation that utilizes validity proofs.
+     */
+    GameType internal constant VALIDITY = GameType.wrap(1);
+    /**
+     * @dev The game will use a `IDisputeGame` implementation that utilizes attestation proofs.
+     */
+    GameType internal constant ATTESTATION = GameType.wrap(2);
 }
--- a/packages/contracts-bedrock/contracts/test/BondManager.t.sol
+++ b/packages/contracts-bedrock/contracts/test/BondManager.t.sol
@@ -208,7 +208,7 @@ contract BondManager_Test is Test {
        {
            rootClaim = Claim.wrap(bytes32(""));
            MockAttestationDisputeGame implementation = new MockAttestationDisputeGame();
-            GameType gt = GameType.ATTESTATION;
+            GameType gt = GameTypes.ATTESTATION;
            factory.setImplementation(gt, IDisputeGame(address(implementation)));
            vm.expectEmit(false, true, true, false);
            emit DisputeGameCreated(address(0), gt, rootClaim);
@@ -261,7 +261,7 @@ contract BondManager_Test is Test {
        {
            rootClaim = Claim.wrap(bytes32(""));
            MockAttestationDisputeGame implementation = new MockAttestationDisputeGame();
-            GameType gt = GameType.ATTESTATION;
+            GameType gt = GameTypes.ATTESTATION;
            factory.setImplementation(gt, IDisputeGame(address(implementation)));
            vm.expectEmit(false, true, true, false);
            emit DisputeGameCreated(address(0), gt, rootClaim);
@@ -418,7 +418,7 @@ contract MockAttestationDisputeGame {
    }
    function gameType() external pure returns (GameType _gameType) {
-        return GameType.ATTESTATION;
+        return GameTypes.ATTESTATION;
    }
    function rootClaim() external view returns (Claim _rootClaim) {

--- a/packages/contracts-bedrock/contracts/test/DisputeGameFactory.t.sol
+++ b/packages/contracts-bedrock/contracts/test/DisputeGameFactory.t.sol
@@ -35,11 +35,11 @@ contract DisputeGameFactory_Test is Test {
        bytes calldata extraData
    ) public {
        // Ensure that the `gameType` is within the bounds of the `GameType` enum's possible values.
-        GameType gt = GameType(uint8(bound(gameType, 0, 2)));
+        GameType gt = GameType.wrap(uint8(bound(gameType, 0, 2)));
        // Set all three implementations to the same `FakeClone` contract.
        for (uint8 i; i < 3; i++) {
-            factory.setImplementation(GameType(i), IDisputeGame(address(fakeClone)));
+            factory.setImplementation(GameType.wrap(i), IDisputeGame(address(fakeClone)));
        }
        vm.expectEmit(false, true, true, false);
@@ -48,6 +48,8 @@ contract DisputeGameFactory_Test is Test {
        // Ensure that the dispute game was assigned to the `disputeGames` mapping.
        assertEq(address(factory.games(gt, rootClaim, extraData)), address(proxy));
+        assertEq(factory.gameCount(), 1);
+        assertEq(address(factory.disputeGameList(0)), address(proxy));
    }
    /**
@@ -60,7 +62,7 @@ contract DisputeGameFactory_Test is Test {
        bytes calldata extraData
    ) public {
        // Ensure that the `gameType` is within the bounds of the `GameType` enum's possible values.
-        GameType gt = GameType(uint8(bound(gameType, 0, 2)));
+        GameType gt = GameType.wrap(uint8(bound(gameType, 0, 2)));
        vm.expectRevert(abi.encodeWithSelector(NoImplementation.selector, gt));
        factory.create(gt, rootClaim, extraData);
@@ -75,11 +77,11 @@ contract DisputeGameFactory_Test is Test {
        bytes calldata extraData
    ) public {
        // Ensure that the `gameType` is within the bounds of the `GameType` enum's possible values.
-        GameType gt = GameType(uint8(bound(gameType, 0, 2)));
+        GameType gt = GameType.wrap(uint8(bound(gameType, 0, 2)));
        // Set all three implementations to the same `FakeClone` contract.
        for (uint8 i; i < 3; i++) {
-            factory.setImplementation(GameType(i), IDisputeGame(address(fakeClone)));
+            factory.setImplementation(GameType.wrap(i), IDisputeGame(address(fakeClone)));
        }
        // Create our first dispute game - this should succeed.
@@ -104,17 +106,17 @@ contract DisputeGameFactory_Test is Test {
     * @dev Tests that the `setImplementation` function properly sets the implementation for a given `GameType`.
     */
    function test_setImplementation_succeeds() public {
-        // There should be no implementation for the `GameType.FAULT` enum value, it has not been set.
+        // There should be no implementation for the `GameTypes.FAULT` enum value, it has not been set.
-        assertEq(address(factory.gameImpls(GameType.FAULT)), address(0));
+        assertEq(address(factory.gameImpls(GameTypes.FAULT)), address(0));
        vm.expectEmit(true, true, true, true, address(factory));
-        emit ImplementationSet(address(1), GameType.FAULT);
+        emit ImplementationSet(address(1), GameTypes.FAULT);
-        // Set the implementation for the `GameType.FAULT` enum value.
+        // Set the implementation for the `GameTypes.FAULT` enum value.
-        factory.setImplementation(GameType.FAULT, IDisputeGame(address(1)));
+        factory.setImplementation(GameTypes.FAULT, IDisputeGame(address(1)));
-        // Ensure that the implementation for the `GameType.FAULT` enum value is set.
+        // Ensure that the implementation for the `GameTypes.FAULT` enum value is set.
-        assertEq(address(factory.gameImpls(GameType.FAULT)), address(1));
+        assertEq(address(factory.gameImpls(GameTypes.FAULT)), address(1));
    }
    /**
@@ -124,7 +126,7 @@ contract DisputeGameFactory_Test is Test {
        // Ensure that the `setImplementation` function reverts when called by a non-owner.
        vm.prank(address(0));
        vm.expectRevert("Ownable: caller is not the owner");
-        factory.setImplementation(GameType.FAULT, IDisputeGame(address(1)));
+        factory.setImplementation(GameTypes.FAULT, IDisputeGame(address(1)));
    }
    /**
@@ -137,7 +139,7 @@ contract DisputeGameFactory_Test is Test {
        bytes calldata extraData
    ) public {
        // Ensure that the `gameType` is within the bounds of the `GameType` enum's possible values.
-        GameType gt = GameType(uint8(bound(gameType, 0, 2)));
+        GameType gt = GameType.wrap(uint8(bound(gameType, 0, 2)));
        assertEq(
            Hash.unwrap(factory.getGameUUID(gt, rootClaim, extraData)),

--- a/packages/contracts-bedrock/deploy-config/devnetL1.json
+++ b/packages/contracts-bedrock/deploy-config/devnetL1.json
@@ -34,6 +34,7 @@
  "l2GenesisBlockBaseFeePerGas": "0x3B9ACA00",
  "gasPriceOracleOverhead": 2100,
  "gasPriceOracleScalar": 1000000,
+  "enableGovernance": true,	
  "governanceTokenSymbol": "OP",
  "governanceTokenName": "Optimism",
  "governanceTokenOwner": "0xBcd4042DE499D14e55001CcbB24a551F3b954096",

--- a/packages/contracts-bedrock/deploy-config/getting-started.json
+++ b/packages/contracts-bedrock/deploy-config/getting-started.json
@@ -43,6 +43,7 @@
  "gasPriceOracleOverhead": 2100,
  "gasPriceOracleScalar": 1000000,
+  "enableGovernance": true,
  "governanceTokenSymbol": "OP",
  "governanceTokenName": "Optimism",
  "governanceTokenOwner": "ADMIN",

--- a/packages/contracts-bedrock/deploy-config/goerli-forked.json
+++ b/packages/contracts-bedrock/deploy-config/goerli-forked.json
@@ -24,6 +24,7 @@
  "proxyAdminOwner": "0x62790eFcB3a5f3A5D398F95B47930A9Addd83807",
+  "enableGovernance": true,
  "governanceTokenName": "Optimism",
  "governanceTokenSymbol": "OP",
  "governanceTokenOwner": "0x038a8825A3C3B0c08d52Cc76E5E361953Cf6Dc76",

--- a/packages/contracts-bedrock/deploy-config/goerli.json
+++ b/packages/contracts-bedrock/deploy-config/goerli.json
@@ -43,6 +43,7 @@
  "gasPriceOracleOverhead": 2100,
  "gasPriceOracleScalar": 1000000,
+  "enableGovernance": true,
  "governanceTokenSymbol": "OP",
  "governanceTokenName": "Optimism",
  "governanceTokenOwner": "0x038a8825A3C3B0c08d52Cc76E5E361953Cf6Dc76",

--- a/packages/contracts-bedrock/deploy-config/hardhat.json
+++ b/packages/contracts-bedrock/deploy-config/hardhat.json
@@ -29,6 +29,7 @@
  "baseFeeVaultWithdrawalNetwork": 0,
  "l1FeeVaultWithdrawalNetwork": 0,
  "sequencerFeeVaultWithdrawalNetwork": 0,
+  "enableGovernance": true,
  "governanceTokenName": "Optimism",
  "governanceTokenSymbol": "OP",
  "governanceTokenOwner": "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc",

--- a/packages/contracts-bedrock/deploy-config/internal-devnet.json
+++ b/packages/contracts-bedrock/deploy-config/internal-devnet.json
@@ -34,6 +34,7 @@
  "l1FeeVaultWithdrawalNetwork": 0,
  "sequencerFeeVaultWithdrawalNetwork": 0,
+  "enableGovernance": true,
  "governanceTokenName": "Optimism",
  "governanceTokenSymbol": "OP",
  "governanceTokenOwner": "0x858F0751ef8B4067f0d2668C076BDB50a8549fbF",

--- a/packages/contracts-bedrock/deploy-config/local.ts
+++ b/packages/contracts-bedrock/deploy-config/local.ts
@@ -37,6 +37,7 @@ const config: DeployConfig = {
  l1FeeVaultWithdrawalNetwork: 0,
  sequencerFeeVaultWithdrawalNetwork: 0,
+  enableGovernance: true,
  governanceTokenName: 'Optimism',
  governanceTokenSymbol: 'OP',
  governanceTokenOwner: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',

--- a/packages/contracts-bedrock/deploy-config/mainnet.json
+++ b/packages/contracts-bedrock/deploy-config/mainnet.json
@@ -28,6 +28,7 @@
  "baseFeeVaultWithdrawalNetwork": 0,
  "l1FeeVaultWithdrawalNetwork": 0,
  "sequencerFeeVaultWithdrawalNetwork": 0,
+  "enableGovernance": true,
  "governanceTokenName": "Optimism",
  "governanceTokenSymbol": "OP",
  "governanceTokenOwner": "0x5C4e7Ba1E219E47948e6e3F55019A647bA501005",

--- a/packages/contracts-bedrock/src/deploy-config.ts
+++ b/packages/contracts-bedrock/src/deploy-config.ts
@@ -110,6 +110,11 @@ interface RequiredDeployConfig {
   */
  l2OutputOracleChallenger: string
+  /**
+   * Whether to enable governance token predeploy.
+   */
+  enableGovernance: boolean
  /**
   * ERC20 symbol used for the L2 GovernanceToken.
   */
@@ -414,13 +419,15 @@ export const deployConfigSpec: {
    type: 'number',
    default: 1_000_000,
  },
+  enableGovernance: {
+    type: 'boolean',
+    default: false,
+  },
  governanceTokenSymbol: {
    type: 'string',
-    default: 'OP',
  },
  governanceTokenName: {
    type: 'string',
-    default: 'Optimism',
  },
  governanceTokenOwner: {
    type: 'string',

--- a/packages/core-utils/README.md
+++ b/packages/core-utils/README.md
@@ -24,32 +24,3 @@ $ yarn start
 $ yarn test
 $ yarn lint
 ```
-### L2 Fees
-`TxGasLimit` can be used to `encode` and `decode` the L2 Gas Limit
-locally.
-```typescript
-import { TxGasLimit } from '@eth-optimism/core-utils'
-import { JsonRpcProvider } from 'ethers'
-const L2Provider = new JsonRpcProvider('https://mainnet.optimism.io')
-const L1Provider = new JsonRpcProvider('http://127.0.0.1:8545')
-const l2GasLimit = await L2Provider.send('eth_estimateExecutionGas', [tx])
-const l1GasPrice = await L1Provider.getGasPrice()
-const encoded = TxGasLimit.encode({
-  data: '0x',
-  l1GasPrice,
-  l2GasLimit,
-  l2GasPrice: 10000000,
-})
-const decoded = TxGasLimit.decode(encoded)
-assert(decoded.eq(gasLimit))
-const estimate = await L2Provider.estimateGas()
-assert(estimate.eq(encoded))
-```
--- a/proxyd/README.md
+++ b/proxyd/README.md
@@ -89,6 +89,52 @@ Cache use Redis and can be enabled for the following immutable methods:
 * `eth_getUncleByBlockHashAndIndex`
 * `debug_getRawReceipts` (block hash only)
+## Meta method `consensus_getReceipts`
+To support backends with different specifications in the same backend group,
+proxyd exposes a convenient method to fetch receipts abstracting away
+what specific backend will serve the request.
+Each backend specifies their preferred method to fetch receipts with `consensus_receipts_target` config,
+which will be translated from `consensus_getReceipts`.
+This method takes a `blockNumberOrHash` (i.e. `tag|qty|hash`)
+and returns the receipts for all transactions in the block.
+Request example
+```json
+{
+  "jsonrpc":"2.0",
+  "id": 1,
+  "params": ["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"]
+}
+```
+It currently supports translation to the following targets:
+* `debug_getRawReceipts(blockOrHash)` (default)
+* `alchemy_getTransactionReceipts(blockOrHash)`
+* `parity_getBlockReceipts(blockOrHash)`
+* `eth_getBlockReceipts(blockOrHash)`
+The selected target is returned in the response, in a wrapped result.
+Response example
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "method": "debug_getRawReceipts",
+    "result": {
+      // the actual raw result from backend
+    }
+  }
+}
+```
+See [op-node receipt fetcher](https://github.com/ethereum-optimism/optimism/blob/186e46a47647a51a658e699e9ff047d39444c2de/op-node/sources/receipts.go#L186-L253).
 ## Metrics
 See `metrics.go` for a list of all available metrics.

--- a/proxyd/backend.go
+++ b/proxyd/backend.go
@@ -18,6 +18,8 @@ import (
 	"time"
 	sw "github.com/ethereum-optimism/optimism/proxyd/pkg/avg-sliding-window"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/gorilla/websocket"
@@ -97,6 +99,9 @@ var (
 	}
 	ErrBackendUnexpectedJSONRPC = errors.New("backend returned an unexpected JSON-RPC response")
+	ErrConsensusGetReceiptsCantBeBatched = errors.New("consensus_getReceipts cannot be batched")
+	ErrConsensusGetReceiptsInvalidTarget = errors.New("unsupported consensus_receipts_target")
 )
 func ErrInvalidRequest(msg string) *RPCErr {
@@ -118,6 +123,7 @@ func ErrInvalidParams(msg string) *RPCErr {
 type Backend struct {
 	Name                 string
 	rpcURL               string
+	receiptsTarget       string
 	wsURL                string
 	authUsername         string
 	authPassword         string
@@ -208,7 +214,7 @@ func WithProxydIP(ip string) BackendOpt {
 	}
 }
-func WithSkipPeerCountCheck(skipPeerCountCheck bool) BackendOpt {
+func WithConsensusSkipPeerCountCheck(skipPeerCountCheck bool) BackendOpt {
 	return func(b *Backend) {
 		b.skipPeerCountCheck = skipPeerCountCheck
 	}
@@ -232,12 +238,36 @@ func WithMaxErrorRateThreshold(maxErrorRateThreshold float64) BackendOpt {
 	}
 }
+func WithConsensusReceiptTarget(receiptsTarget string) BackendOpt {
+	return func(b *Backend) {
+		b.receiptsTarget = receiptsTarget
+	}
+}
 type indexedReqRes struct {
 	index int
 	req   *RPCReq
 	res   *RPCRes
 }
+const ConsensusGetReceiptsMethod = "consensus_getReceipts"
+const ReceiptsTargetDebugGetRawReceipts = "debug_getRawReceipts"
+const ReceiptsTargetAlchemyGetTransactionReceipts = "alchemy_getTransactionReceipts"
+const ReceiptsTargetParityGetTransactionReceipts = "parity_getBlockReceipts"
+const ReceiptsTargetEthGetTransactionReceipts = "eth_getBlockReceipts"
+type ConsensusGetReceiptsResult struct {
+	Method string      `json:"method"`
+	Result interface{} `json:"result"`
+}
+// BlockHashOrNumberParameter is a non-conventional wrapper used by alchemy_getTransactionReceipts
+type BlockHashOrNumberParameter struct {
+	BlockHash   *common.Hash     `json:"blockHash"`
+	BlockNumber *rpc.BlockNumber `json:"blockNumber"`
+}
 func NewBackend(
 	name string,
 	rpcURL string,
@@ -266,9 +296,7 @@ func NewBackend(
 		networkErrorsSlidingWindow:   sw.NewSlidingWindow(),
 	}
-	for _, opt := range opts {
+	backend.Override(opts...)
-		opt(backend)
-	}
 	if !backend.stripTrailingXFF && backend.proxydIP == "" {
 		log.Warn("proxied requests' XFF header will not contain the proxyd ip address")
@@ -277,6 +305,12 @@ func NewBackend(
 	return backend
 }
+func (b *Backend) Override(opts ...BackendOpt) {
+	for _, opt := range opts {
+		opt(b)
+	}
+}
 func (b *Backend) Forward(ctx context.Context, reqs []*RPCReq, isBatch bool) ([]*RPCRes, error) {
 	var lastError error
 	// <= to account for the first attempt not technically being
@@ -298,6 +332,20 @@ func (b *Backend) Forward(ctx context.Context, reqs []*RPCReq, isBatch bool) ([]
 		res, err := b.doForward(ctx, reqs, isBatch)
 		switch err {
 		case nil: // do nothing
+		case ErrConsensusGetReceiptsCantBeBatched:
+			log.Warn(
+				"Received unsupported batch request for consensus_getReceipts",
+				"name", b.Name,
+				"req_id", GetReqID(ctx),
+				"err", err,
+			)
+		case ErrConsensusGetReceiptsInvalidTarget:
+			log.Error(
+				"Unsupported consensus_receipts_target for consensus_getReceipts",
+				"name", b.Name,
+				"req_id", GetReqID(ctx),
+				"err", err,
+			)
 		// ErrBackendUnexpectedJSONRPC occurs because infura responds with a single JSON-RPC object
 		// to a batch request whenever any Request Object in the batch would induce a partial error.
 		// We don't label the backend offline in this case. But the error is still returned to
@@ -375,11 +423,63 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 	// we are concerned about network error rates, so we record 1 request independently of how many are in the batch
 	b.networkRequestsSlidingWindow.Incr()
+	translatedReqs := make(map[string]*RPCReq, len(rpcReqs))
+	// translate consensus_getReceipts to receipts target
+	// right now we only support non-batched
+	if isBatch {
+		for _, rpcReq := range rpcReqs {
+			if rpcReq.Method == ConsensusGetReceiptsMethod {
+				return nil, ErrConsensusGetReceiptsCantBeBatched
+			}
+		}
+	} else {
+		for _, rpcReq := range rpcReqs {
+			if rpcReq.Method == ConsensusGetReceiptsMethod {
+				translatedReqs[string(rpcReq.ID)] = rpcReq
+				rpcReq.Method = b.receiptsTarget
+				var reqParams []rpc.BlockNumberOrHash
+				err := json.Unmarshal(rpcReq.Params, &reqParams)
+				if err != nil {
+					return nil, ErrInvalidRequest("invalid request")
+				}
+				var translatedParams []byte
+				switch rpcReq.Method {
+				case ReceiptsTargetDebugGetRawReceipts,
+					ReceiptsTargetEthGetTransactionReceipts,
+					ReceiptsTargetParityGetTransactionReceipts:
+					// conventional methods use an array of strings having either block number or block hash
+					// i.e. ["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"]
+					params := make([]string, 1)
+					if reqParams[0].BlockNumber != nil {
+						params[0] = reqParams[0].BlockNumber.String()
+					} else {
+						params[0] = reqParams[0].BlockHash.Hex()
+					}
+					translatedParams = mustMarshalJSON(params)
+				case ReceiptsTargetAlchemyGetTransactionReceipts:
+					// alchemy uses an array of object with either block number or block hash
+					// i.e. [{ blockHash: "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b" }]
+					params := make([]BlockHashOrNumberParameter, 1)
+					if reqParams[0].BlockNumber != nil {
+						params[0].BlockNumber = reqParams[0].BlockNumber
+					} else {
+						params[0].BlockHash = reqParams[0].BlockHash
+					}
+					translatedParams = mustMarshalJSON(params)
+				default:
+					return nil, ErrConsensusGetReceiptsInvalidTarget
+				}
+				rpcReq.Params = translatedParams
+			}
+		}
+	}
 	isSingleElementBatch := len(rpcReqs) == 1
 	// Single element batches are unwrapped before being sent
 	// since Alchemy handles single requests better than batches.
 	var body []byte
 	if isSingleElementBatch {
 		body = mustMarshalJSON(rpcReqs[0])
@@ -443,17 +543,17 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 		return nil, wrapErr(err, "error reading response body")
 	}
-	var res []*RPCRes
+	var rpcRes []*RPCRes
 	if isSingleElementBatch {
 		var singleRes RPCRes
 		if err := json.Unmarshal(resB, &singleRes); err != nil {
 			return nil, ErrBackendBadResponse
 		}
-		res = []*RPCRes{
+		rpcRes = []*RPCRes{
 			&singleRes,
 		}
 	} else {
-		if err := json.Unmarshal(resB, &res); err != nil {
+		if err := json.Unmarshal(resB, &rpcRes); err != nil {
 			// Infura may return a single JSON-RPC response if, for example, the batch contains a request for an unsupported method
 			if responseIsNotBatched(resB) {
 				b.networkErrorsSlidingWindow.Incr()
@@ -466,7 +566,7 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 		}
 	}
-	if len(rpcReqs) != len(res) {
+	if len(rpcReqs) != len(rpcRes) {
 		b.networkErrorsSlidingWindow.Incr()
 		RecordBackendNetworkErrorRateSlidingWindow(b, b.ErrorRate())
 		return nil, ErrBackendUnexpectedJSONRPC
@@ -475,7 +575,7 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 	// capture the HTTP status code in the response. this will only
 	// ever be 400 given the status check on line 318 above.
 	if httpRes.StatusCode != 200 {
-		for _, res := range res {
+		for _, res := range rpcRes {
 			res.Error.HTTPErrorCode = httpRes.StatusCode
 		}
 	}
@@ -484,8 +584,20 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 	RecordBackendNetworkLatencyAverageSlidingWindow(b, time.Duration(b.latencySlidingWindow.Avg()))
 	RecordBackendNetworkErrorRateSlidingWindow(b, b.ErrorRate())
-	sortBatchRPCResponse(rpcReqs, res)
+	// enrich the response with the actual request method
-	return res, nil
+	for _, res := range rpcRes {
+		translatedReq, exist := translatedReqs[string(res.ID)]
+		if exist {
+			res.Result = ConsensusGetReceiptsResult{
+				Method: translatedReq.Method,
+				Result: res.Result,
+			}
+		}
+	}
+	sortBatchRPCResponse(rpcReqs, rpcRes)
+	return rpcRes, nil
 }
 // IsHealthy checks if the backend is able to serve traffic, based on dynamic parameters
@@ -604,7 +716,9 @@ func (bg *BackendGroup) Forward(ctx context.Context, rpcReqs []*RPCReq, isBatch
 		if len(rpcReqs) > 0 {
 			res, err = back.Forward(ctx, rpcReqs, isBatch)
-			if errors.Is(err, ErrMethodNotWhitelisted) {
+			if errors.Is(err, ErrConsensusGetReceiptsCantBeBatched) ||
+				errors.Is(err, ErrConsensusGetReceiptsInvalidTarget) ||
+				errors.Is(err, ErrMethodNotWhitelisted) {
 				return nil, err
 			}
 			if errors.Is(err, ErrBackendOffline) {

--- a/proxyd/config.go
+++ b/proxyd/config.go
@@ -79,18 +79,20 @@ type BackendOptions struct {
 }
 type BackendConfig struct {
-	Username           string `toml:"username"`
+	Username         string `toml:"username"`
-	Password           string `toml:"password"`
+	Password         string `toml:"password"`
-	RPCURL             string `toml:"rpc_url"`
+	RPCURL           string `toml:"rpc_url"`
-	WSURL              string `toml:"ws_url"`
+	WSURL            string `toml:"ws_url"`
-	WSPort             int    `toml:"ws_port"`
+	WSPort           int    `toml:"ws_port"`
-	MaxRPS             int    `toml:"max_rps"`
+	MaxRPS           int    `toml:"max_rps"`
-	MaxWSConns         int    `toml:"max_ws_conns"`
+	MaxWSConns       int    `toml:"max_ws_conns"`
-	CAFile             string `toml:"ca_file"`
+	CAFile           string `toml:"ca_file"`
-	ClientCertFile     string `toml:"client_cert_file"`
+	ClientCertFile   string `toml:"client_cert_file"`
-	ClientKeyFile      string `toml:"client_key_file"`
+	ClientKeyFile    string `toml:"client_key_file"`
-	StripTrailingXFF   bool   `toml:"strip_trailing_xff"`
+	StripTrailingXFF bool   `toml:"strip_trailing_xff"`
-	SkipPeerCountCheck bool   `toml:"consensus_skip_peer_count"`
+	ConsensusSkipPeerCountCheck bool   `toml:"consensus_skip_peer_count"`
+	ConsensusReceiptsTarget     string `toml:"consensus_receipts_target"`
 }
 type BackendsConfig map[string]*BackendConfig

--- a/proxyd/example.config.toml
+++ b/proxyd/example.config.toml
@@ -74,7 +74,9 @@ client_cert_file = ""
 client_key_file = ""
 # Allows backends to skip peer count checking, default false
 # consensus_skip_peer_count = true
+# Specified the target method to get receipts, default "debug_getRawReceipts"
+# See https://github.com/ethereum-optimism/optimism/blob/186e46a47647a51a658e699e9ff047d39444c2de/op-node/sources/receipts.go#L186-L253
+consensus_receipts_target = "eth_getBlockReceipts"
 [backends.alchemy]
 rpc_url = ""
@@ -83,6 +85,7 @@ username = ""
 password = ""
 max_rps = 3
 max_ws_conns = 1
+consensus_receipts_target = "alchemy_getTransactionReceipts"
 [backend_groups]
 [backend_groups.main]

--- a/proxyd/go.mod
+++ b/proxyd/go.mod
@@ -9,6 +9,7 @@ require (
 	github.com/ethereum/go-ethereum v1.12.0
 	github.com/go-redis/redis/v8 v8.11.4
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb
+	github.com/google/uuid v1.3.0
 	github.com/gorilla/mux v1.8.0
 	github.com/gorilla/websocket v1.5.0
 	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d

--- a/proxyd/go.sum
+++ b/proxyd/go.sum
@@ -157,6 +157,8 @@ github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=

--- a/proxyd/integration_tests/consensus_test.go
+++ b/proxyd/integration_tests/consensus_test.go
@@ -784,6 +784,211 @@ func TestConsensus(t *testing.T) {
 		// dont rewrite for 0xe1
 		require.Equal(t, "0xe1", jsonMap[2]["result"].(map[string]interface{})["number"])
 	})
+	t.Run("translate consensus_getReceipts to debug_getRawReceipts", func(t *testing.T) {
+		reset()
+		useOnlyNode1()
+		update()
+		// reset request counts
+		nodes["node1"].mockBackend.Reset()
+		resRaw, statusCode, err := client.SendRPC("consensus_getReceipts",
+			[]interface{}{"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"})
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+		var jsonMap map[string]interface{}
+		err = json.Unmarshal(nodes["node1"].mockBackend.Requests()[0].Body, &jsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "debug_getRawReceipts", jsonMap["method"])
+		require.Equal(t, "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", jsonMap["params"].([]interface{})[0])
+		var resJsonMap map[string]interface{}
+		err = json.Unmarshal(resRaw, &resJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "debug_getRawReceipts", resJsonMap["result"].(map[string]interface{})["method"].(string))
+		require.Equal(t, "debug_getRawReceipts", resJsonMap["result"].(map[string]interface{})["result"].(map[string]interface{})["_"])
+	})
+	t.Run("translate consensus_getReceipts to debug_getRawReceipts with latest block tag", func(t *testing.T) {
+		reset()
+		useOnlyNode1()
+		update()
+		// reset request counts
+		nodes["node1"].mockBackend.Reset()
+		resRaw, statusCode, err := client.SendRPC("consensus_getReceipts",
+			[]interface{}{"latest"})
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+		var jsonMap map[string]interface{}
+		err = json.Unmarshal(nodes["node1"].mockBackend.Requests()[0].Body, &jsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "debug_getRawReceipts", jsonMap["method"])
+		require.Equal(t, "0x101", jsonMap["params"].([]interface{})[0])
+		var resJsonMap map[string]interface{}
+		err = json.Unmarshal(resRaw, &resJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "debug_getRawReceipts", resJsonMap["result"].(map[string]interface{})["method"].(string))
+		require.Equal(t, "debug_getRawReceipts", resJsonMap["result"].(map[string]interface{})["result"].(map[string]interface{})["_"])
+	})
+	t.Run("translate consensus_getReceipts to debug_getRawReceipts with block number", func(t *testing.T) {
+		reset()
+		useOnlyNode1()
+		update()
+		// reset request counts
+		nodes["node1"].mockBackend.Reset()
+		resRaw, statusCode, err := client.SendRPC("consensus_getReceipts",
+			[]interface{}{"0x55"})
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+		var jsonMap map[string]interface{}
+		err = json.Unmarshal(nodes["node1"].mockBackend.Requests()[0].Body, &jsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "debug_getRawReceipts", jsonMap["method"])
+		require.Equal(t, "0x55", jsonMap["params"].([]interface{})[0])
+		var resJsonMap map[string]interface{}
+		err = json.Unmarshal(resRaw, &resJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "debug_getRawReceipts", resJsonMap["result"].(map[string]interface{})["method"].(string))
+		require.Equal(t, "debug_getRawReceipts", resJsonMap["result"].(map[string]interface{})["result"].(map[string]interface{})["_"])
+	})
+	t.Run("translate consensus_getReceipts to alchemy_getTransactionReceipts with block hash", func(t *testing.T) {
+		reset()
+		useOnlyNode1()
+		update()
+		// reset request counts
+		nodes["node1"].mockBackend.Reset()
+		nodes["node1"].backend.Override(proxyd.WithConsensusReceiptTarget("alchemy_getTransactionReceipts"))
+		defer nodes["node1"].backend.Override(proxyd.WithConsensusReceiptTarget("debug_getRawReceipts"))
+		resRaw, statusCode, err := client.SendRPC("consensus_getReceipts",
+			[]interface{}{"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"})
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+		var reqJsonMap map[string]interface{}
+		err = json.Unmarshal(nodes["node1"].mockBackend.Requests()[0].Body, &reqJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "alchemy_getTransactionReceipts", reqJsonMap["method"])
+		require.Equal(t, "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", reqJsonMap["params"].([]interface{})[0].(map[string]interface{})["blockHash"])
+		var resJsonMap map[string]interface{}
+		err = json.Unmarshal(resRaw, &resJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "alchemy_getTransactionReceipts", resJsonMap["result"].(map[string]interface{})["method"].(string))
+		require.Equal(t, "alchemy_getTransactionReceipts", resJsonMap["result"].(map[string]interface{})["result"].(map[string]interface{})["_"])
+	})
+	t.Run("translate consensus_getReceipts to alchemy_getTransactionReceipts with block number", func(t *testing.T) {
+		reset()
+		useOnlyNode1()
+		update()
+		// reset request counts
+		nodes["node1"].mockBackend.Reset()
+		nodes["node1"].backend.Override(proxyd.WithConsensusReceiptTarget("alchemy_getTransactionReceipts"))
+		defer nodes["node1"].backend.Override(proxyd.WithConsensusReceiptTarget("debug_getRawReceipts"))
+		resRaw, statusCode, err := client.SendRPC("consensus_getReceipts",
+			[]interface{}{"0x55"})
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+		var reqJsonMap map[string]interface{}
+		err = json.Unmarshal(nodes["node1"].mockBackend.Requests()[0].Body, &reqJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "alchemy_getTransactionReceipts", reqJsonMap["method"])
+		require.Equal(t, "0x55", reqJsonMap["params"].([]interface{})[0].(map[string]interface{})["blockNumber"])
+		var resJsonMap map[string]interface{}
+		err = json.Unmarshal(resRaw, &resJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "alchemy_getTransactionReceipts", resJsonMap["result"].(map[string]interface{})["method"].(string))
+		require.Equal(t, "alchemy_getTransactionReceipts", resJsonMap["result"].(map[string]interface{})["result"].(map[string]interface{})["_"])
+	})
+	t.Run("translate consensus_getReceipts to alchemy_getTransactionReceipts with latest block tag", func(t *testing.T) {
+		reset()
+		useOnlyNode1()
+		update()
+		// reset request counts
+		nodes["node1"].mockBackend.Reset()
+		nodes["node1"].backend.Override(proxyd.WithConsensusReceiptTarget("alchemy_getTransactionReceipts"))
+		defer nodes["node1"].backend.Override(proxyd.WithConsensusReceiptTarget("debug_getRawReceipts"))
+		resRaw, statusCode, err := client.SendRPC("consensus_getReceipts",
+			[]interface{}{"latest"})
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+		var reqJsonMap map[string]interface{}
+		err = json.Unmarshal(nodes["node1"].mockBackend.Requests()[0].Body, &reqJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "alchemy_getTransactionReceipts", reqJsonMap["method"])
+		require.Equal(t, "0x101", reqJsonMap["params"].([]interface{})[0].(map[string]interface{})["blockNumber"])
+		var resJsonMap map[string]interface{}
+		err = json.Unmarshal(resRaw, &resJsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "alchemy_getTransactionReceipts", resJsonMap["result"].(map[string]interface{})["method"].(string))
+		require.Equal(t, "alchemy_getTransactionReceipts", resJsonMap["result"].(map[string]interface{})["result"].(map[string]interface{})["_"])
+	})
+	t.Run("translate consensus_getReceipts to unsupported consensus_receipts_target", func(t *testing.T) {
+		reset()
+		useOnlyNode1()
+		nodes["node1"].backend.Override(proxyd.WithConsensusReceiptTarget("unsupported_consensus_receipts_target"))
+		defer nodes["node1"].backend.Override(proxyd.WithConsensusReceiptTarget("debug_getRawReceipts"))
+		_, statusCode, err := client.SendRPC("consensus_getReceipts",
+			[]interface{}{"latest"})
+		require.NoError(t, err)
+		require.Equal(t, 400, statusCode)
+	})
+	t.Run("consensus_getReceipts should not be used in a batch", func(t *testing.T) {
+		reset()
+		useOnlyNode1()
+		_, statusCode, err := client.SendBatchRPC(
+			NewRPCReq("1", "eth_getBlockByNumber", []interface{}{"latest"}),
+			NewRPCReq("2", "consensus_getReceipts", []interface{}{"0x55"}),
+			NewRPCReq("3", "eth_getBlockByNumber", []interface{}{"0xe1"}))
+		require.NoError(t, err)
+		require.Equal(t, 400, statusCode)
+	})
 }
 func buildResponse(result interface{}) string {

--- a/proxyd/integration_tests/testdata/consensus.toml
+++ b/proxyd/integration_tests/testdata/consensus.toml
@@ -27,3 +27,4 @@ eth_call = "node"
 eth_chainId = "node"
 eth_blockNumber = "node"
 eth_getBlockByNumber = "node"
+consensus_getReceipts = "node"
--- a/proxyd/integration_tests/testdata/consensus_responses.yml
+++ b/proxyd/integration_tests/testdata/consensus_responses.yml
@@ -184,3 +184,30 @@
        "number": "0xd1"
      }
    }
+- method: debug_getRawReceipts
+  response: >
+    {
+      "jsonrpc": "2.0",
+      "id": 67,
+      "result": {
+        "_": "debug_getRawReceipts"
+      }
+    }
+- method: eth_getTransactionReceipt
+  response: >
+    {
+      "jsonrpc": "2.0",
+      "id": 67,
+      "result": {
+        "_": "eth_getTransactionReceipt"
+      }
+    }
+- method: alchemy_getTransactionReceipts
+  response: >
+    {
+      "jsonrpc": "2.0",
+      "id": 67,
+      "result": {
+        "_": "alchemy_getTransactionReceipts"
+      }
+    }
--- a/proxyd/proxyd.go
+++ b/proxyd/proxyd.go
@@ -141,7 +141,17 @@ func Start(config *Config) (*Server, func(), error) {
 			opts = append(opts, WithStrippedTrailingXFF())
 		}
 		opts = append(opts, WithProxydIP(os.Getenv("PROXYD_IP")))
-		opts = append(opts, WithSkipPeerCountCheck(cfg.SkipPeerCountCheck))
+		opts = append(opts, WithConsensusSkipPeerCountCheck(cfg.ConsensusSkipPeerCountCheck))
+		receiptsTarget, err := ReadFromEnvOrConfig(cfg.ConsensusReceiptsTarget)
+		if err != nil {
+			return nil, nil, err
+		}
+		receiptsTarget, err = validateReceiptsTarget(receiptsTarget)
+		if err != nil {
+			return nil, nil, err
+		}
+		opts = append(opts, WithConsensusReceiptTarget(receiptsTarget))
 		back := NewBackend(name, rpcURL, wsURL, rpcRequestSemaphore, opts...)
 		backendNames = append(backendNames, name)
@@ -316,6 +326,21 @@ func Start(config *Config) (*Server, func(), error) {
 	return srv, shutdownFunc, nil
 }
+func validateReceiptsTarget(val string) (string, error) {
+	if val == "" {
+		val = ReceiptsTargetDebugGetRawReceipts
+	}
+	switch val {
+	case ReceiptsTargetDebugGetRawReceipts,
+		ReceiptsTargetAlchemyGetTransactionReceipts,
+		ReceiptsTargetEthGetTransactionReceipts,
+		ReceiptsTargetParityGetTransactionReceipts:
+		return val, nil
+	default:
+		return "", fmt.Errorf("invalid receipts target: %s", val)
+	}
+}
 func secondsToDuration(seconds int) time.Duration {
 	return time.Duration(seconds) * time.Second
 }

--- a/proxyd/rewriter.go
+++ b/proxyd/rewriter.go
@@ -63,7 +63,7 @@ func RewriteRequest(rctx RewriteContext, req *RPCReq, res *RPCRes) (RewriteResul
 	case "eth_getLogs",
 		"eth_newFilter":
 		return rewriteRange(rctx, req, res, 0)
-	case "debug_getRawReceipts":
+	case "debug_getRawReceipts", "consensus_getReceipts":
 		return rewriteParam(rctx, req, res, 0, true)
 	case "eth_getBalance",
 		"eth_getCode",

--- a/proxyd/server.go
+++ b/proxyd/server.go
@@ -347,6 +347,11 @@ func (s *Server) HandleRPC(w http.ResponseWriter, r *http.Request) {
 			writeRPCError(ctx, w, nil, ErrGatewayTimeout)
 			return
 		}
+		if errors.Is(err, ErrConsensusGetReceiptsCantBeBatched) ||
+			errors.Is(err, ErrConsensusGetReceiptsInvalidTarget) {
+			writeRPCError(ctx, w, nil, ErrInvalidRequest(err.Error()))
+			return
+		}
 		if err != nil {
 			writeRPCError(ctx, w, nil, ErrInternal)
 			return
@@ -360,6 +365,11 @@ func (s *Server) HandleRPC(w http.ResponseWriter, r *http.Request) {
 	rawBody := json.RawMessage(body)
 	backendRes, cached, err := s.handleBatchRPC(ctx, []json.RawMessage{rawBody}, isLimited, false)
 	if err != nil {
+		if errors.Is(err, ErrConsensusGetReceiptsCantBeBatched) ||
+			errors.Is(err, ErrConsensusGetReceiptsInvalidTarget) {
+			writeRPCError(ctx, w, nil, ErrInvalidRequest(err.Error()))
+			return
+		}
 		writeRPCError(ctx, w, nil, ErrInternal)
 		return
 	}
@@ -485,6 +495,10 @@ func (s *Server) handleBatchRPC(ctx context.Context, reqs []json.RawMessage, isL
 			elems := cacheMisses[start:end]
 			res, err := s.BackendGroups[group.backendGroup].Forward(ctx, createBatchRequest(elems), isBatch)
 			if err != nil {
+				if errors.Is(err, ErrConsensusGetReceiptsCantBeBatched) ||
+					errors.Is(err, ErrConsensusGetReceiptsInvalidTarget) {
+					return nil, false, err
+				}
 				log.Error(
 					"error forwarding RPC batch",
 					"batch_size", len(elems),

--- a/proxyd/tools/mockserver/handler/handler.go
+++ b/proxyd/tools/mockserver/handler/handler.go
@@ -88,7 +88,15 @@ func (mh *MockedHandler) Handler(w http.ResponseWriter, req *http.Request) {
 			}
 		}
 		if selectedResponse != "" {
-			responses = append(responses, selectedResponse)
+			var rpcRes proxyd.RPCRes
+			err = json.Unmarshal([]byte(selectedResponse), &rpcRes)
+			if err != nil {
+				panic(err)
+			}
+			idJson, _ := json.Marshal(r["id"])
+			rpcRes.ID = idJson
+			res, _ := json.Marshal(rpcRes)
+			responses = append(responses, string(res))
 		}
 	}