Merge branch 'develop' into refcell/challenger/dir

op-batcher/flags/flags.go

@@ -110,6 +110,7 @@ var optionalFlags = []cli.Flag{
 	TargetNumFramesFlag,
 	ApproxComprRatioFlag,
 	StoppedFlag,
+	SequencerHDPathFlag,
 }
 
 func init() {

op-program/host/prefetcher/retry.go

@@ -47,7 +47,7 @@ func (s *RetryingL1Source) InfoAndTxsByHash(ctx context.Context, blockHash commo
 	err := backoff.DoCtx(ctx, maxAttempts, s.strategy, func() error {
 		i, t, err := s.source.InfoAndTxsByHash(ctx, blockHash)
 		if err != nil {
-			s.logger.Warn("Failed to retrieve info and txs", "hash", blockHash, "err", err)
+			s.logger.Warn("Failed to retrieve l1 info and txs", "hash", blockHash, "err", err)
 			return err
 		}
 		info = i
@@ -87,7 +87,7 @@ func (s *RetryingL2Source) InfoAndTxsByHash(ctx context.Context, blockHash commo
 	err := backoff.DoCtx(ctx, maxAttempts, s.strategy, func() error {
 		i, t, err := s.source.InfoAndTxsByHash(ctx, blockHash)
 		if err != nil {
-			s.logger.Warn("Failed to retrieve info and txs", "hash", blockHash, "err", err)
+			s.logger.Warn("Failed to retrieve l2 info and txs", "hash", blockHash, "err", err)
 			return err
 		}
 		info = i

op-proposer/flags/flags.go

@@ -59,11 +59,11 @@ var requiredFlags = []cli.Flag{
 var optionalFlags = []cli.Flag{
 	PollIntervalFlag,
 	AllowNonFinalizedFlag,
+	L2OutputHDPathFlag,
 }
 
 func init() {
-	requiredFlags = append(requiredFlags, oprpc.CLIFlags(envVarPrefix)...)
-
+	optionalFlags = append(optionalFlags, oprpc.CLIFlags(envVarPrefix)...)
 	optionalFlags = append(optionalFlags, oplog.CLIFlags(envVarPrefix)...)
 	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(envVarPrefix)...)
 	optionalFlags = append(optionalFlags, oppprof.CLIFlags(envVarPrefix)...)

op-service/txmgr/cli.go

@@ -60,10 +60,8 @@ func CLIFlags(envPrefix string) []cli.Flag {
 			Usage:  "The HD path used to derive the sequencer wallet from the mnemonic. The mnemonic flag must also be set.",
 			EnvVar: opservice.PrefixEnvVar(envPrefix, "HD_PATH"),
 		},
-		SequencerHDPathFlag,
-		L2OutputHDPathFlag,
 		cli.StringFlag{
-			Name:   "private-key",
+			Name:   PrivateKeyFlagName,
 			Usage:  "The private key to use with the service. Must not be used with mnemonic.",
 			EnvVar: opservice.PrefixEnvVar(envPrefix, "PRIVATE_KEY"),
 		},

ops/check-changed/main.py

@@ -11,7 +11,9 @@ REBUILD_ALL_PATTERNS = [
     r'^\.github/\.*',
     r'^package\.json',
     r'^yarn\.lock',
-    r'ops/check-changed/.*'
+    r'ops/check-changed/.*',
+    r'^go\.mod',
+    r'^go\.sum',
 ]
 
 WHITELISTED_BRANCHES = {

packages/contracts-bedrock/deploy-config/mainnet.ts

 import { DeployConfig } from '../src/deploy-config'
+import mainnetJson from './mainnet.json'
 
 // NOTE: The 'mainnet' network is currently being used for bedrock migration rehearsals.
 // The system configured below is not yet live on mainnet, and many of the addresses used are
 // unsafe for a production system.
 
-// The following addresses are assigned to multiples roles in the system, therfore we save them
-// as constants to avoid having to change them in multiple places.
-const foundationMultisig = '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266' // hh test signer 0
-const feeRecipient = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8' // hh test signer 1
-const mintManager = '0x5C4e7Ba1E219E47948e6e3F55019A647bA501005'
-
-const config: DeployConfig = {
-  finalSystemOwner: foundationMultisig,
-  controller: foundationMultisig,
-  portalGuardian: foundationMultisig,
-  proxyAdminOwner: foundationMultisig,
-
-  l1StartingBlockTag:
-    '0x126e52a0cc0ae18948f567ee9443f4a8f0db67c437706e35baee424eb314a0d0',
-  l1ChainID: 1,
-  l2ChainID: 10,
-  l2BlockTime: 2,
-
-  maxSequencerDrift: 600,
-  sequencerWindowSize: 3600,
-  channelTimeout: 300,
-
-  p2pSequencerAddress: '0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65',
-  batchInboxAddress: '0xff00000000000000000000000000000000000010',
-  batchSenderAddress: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
-  l2OutputOracleSubmissionInterval: 20,
-  l2OutputOracleStartingTimestamp: 1679069195,
-  l2OutputOracleStartingBlockNumber: 79149704,
-  l2OutputOracleProposer: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
-  l2OutputOracleChallenger: foundationMultisig,
-  finalizationPeriodSeconds: 2,
-
-  baseFeeVaultRecipient: feeRecipient,
-  l1FeeVaultRecipient: feeRecipient,
-  sequencerFeeVaultRecipient: feeRecipient,
-
-  governanceTokenName: 'Optimism',
-  governanceTokenSymbol: 'OP',
-  governanceTokenOwner: mintManager,
-
-  l2GenesisBlockGasLimit: '0x1c9c380',
-  l2GenesisBlockCoinbase: '0x4200000000000000000000000000000000000011',
-  l2GenesisBlockBaseFeePerGas: '0x3b9aca00',
-
-  gasPriceOracleOverhead: 2100,
-  gasPriceOracleScalar: 1000000,
-  eip1559Denominator: 50,
-  eip1559Elasticity: 10,
-
-  l2GenesisRegolithTimeOffset: '0x0',
-}
+// Re-export the mainnet json as a DeployConfig object.
+//
+// Notice, the following roles in the system are assigned to the:
+// Optimism Foundation Mulitisig:
+// - finalSystemOwner
+// - controller
+// - portalGuardian
+// - proxyAdminOwner
+// - l2OutputOracleChallenger
+//
+// The following roles are assigned to the same fee recipient:
+// - baseFeeVaultRecipient
+// - l1FeeVaultRecipient
+// - sequencerFeeVaultRecipient
+//
+// The following role is assigned to the Mint Manager contract:
+// - governanceTokenOwner
+const config: DeployConfig = mainnetJson
 
 export default config

packages/sdk/tasks/deposit-eth.ts

@@ -27,12 +27,6 @@ task('deposit-eth', 'Deposits ether to L2.')
     'http://localhost:9545',
     types.string
   )
-  .addParam(
-    'opNodeProviderUrl',
-    'op-node provider URL',
-    'http://localhost:7545',
-    types.string
-  )
   .addOptionalParam('to', 'Recipient of the ether', '', types.string)
   .addOptionalParam(
     'amount',

proxyd/backend.go

@@ -90,6 +90,11 @@ var (
 		Message:       "backend is currently not healthy to serve traffic",
 		HTTPErrorCode: 503,
 	}
+	ErrBlockOutOfRange = &RPCErr{
+		Code:          JSONRPCErrorInternal - 19,
+		Message:       "block is out of range",
+		HTTPErrorCode: 400,
+	}
 
 	ErrBackendUnexpectedJSONRPC = errors.New("backend returned an unexpected JSON-RPC response")
 )
@@ -202,6 +207,12 @@ func WithProxydIP(ip string) BackendOpt {
 	}
 }
 
+func WithMaxDegradedLatencyThreshold(maxDegradedLatencyThreshold time.Duration) BackendOpt {
+	return func(b *Backend) {
+		b.maxDegradedLatencyThreshold = maxDegradedLatencyThreshold
+	}
+}
+
 func WithMaxLatencyThreshold(maxLatencyThreshold time.Duration) BackendOpt {
 	return func(b *Backend) {
 		b.maxLatencyThreshold = maxLatencyThreshold
@@ -214,6 +225,12 @@ func WithMaxErrorRateThreshold(maxErrorRateThreshold float64) BackendOpt {
 	}
 }
 
+type indexedReqRes struct {
+	index int
+	req   *RPCReq
+	res   *RPCRes
+}
+
 func NewBackend(
 	name string,
 	rpcURL string,
@@ -540,7 +557,11 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool
 
 // IsHealthy checks if the backend is able to serve traffic, based on dynamic parameters
 func (b *Backend) IsHealthy() bool {
-	errorRate := b.networkErrorsSlidingWindow.Sum() / b.networkRequestsSlidingWindow.Sum()
+	errorRate := float64(0)
+	// avoid division-by-zero when the window is empty
+	if b.networkRequestsSlidingWindow.Sum() >= 10 {
+		errorRate = b.networkErrorsSlidingWindow.Sum() / b.networkRequestsSlidingWindow.Sum()
+	}
 	avgLatency := time.Duration(b.latencySlidingWindow.Avg())
 	if errorRate >= b.maxErrorRateThreshold {
 		return false
@@ -593,16 +614,53 @@ func (b *BackendGroup) Forward(ctx context.Context, rpcReqs []*RPCReq, isBatch b
 
 	backends := b.Backends
 
+	overriddenResponses := make([]*indexedReqRes, 0)
+	rewrittenReqs := make([]*RPCReq, 0, len(rpcReqs))
+
+	if b.Consensus != nil {
 		// When `consensus_aware` is set to `true`, the backend group acts as a load balancer
 		// serving traffic from any backend that agrees in the consensus group
-	if b.Consensus != nil {
 		backends = b.loadBalancedConsensusGroup()
+
+		// We also rewrite block tags to enforce compliance with consensus
+		rctx := RewriteContext{latest: b.Consensus.GetConsensusBlockNumber()}
+
+		for i, req := range rpcReqs {
+			res := RPCRes{JSONRPC: JSONRPCVersion, ID: req.ID}
+			result, err := RewriteTags(rctx, req, &res)
+			switch result {
+			case RewriteOverrideError:
+				overriddenResponses = append(overriddenResponses, &indexedReqRes{
+					index: i,
+					req:   req,
+					res:   &res,
+				})
+				if errors.Is(err, ErrRewriteBlockOutOfRange) {
+					res.Error = ErrBlockOutOfRange
+				} else {
+					res.Error = ErrParseErr
+				}
+			case RewriteOverrideResponse:
+				overriddenResponses = append(overriddenResponses, &indexedReqRes{
+					index: i,
+					req:   req,
+					res:   &res,
+				})
+			case RewriteOverrideRequest, RewriteNone:
+				rewrittenReqs = append(rewrittenReqs, req)
+			}
+		}
+		rpcReqs = rewrittenReqs
 	}
 
 	rpcRequestsTotal.Inc()
 
 	for _, back := range backends {
-		res, err := back.Forward(ctx, rpcReqs, isBatch)
+		res := make([]*RPCRes, 0)
+		var err error
+
+		if len(rpcReqs) > 0 {
+			res, err = back.Forward(ctx, rpcReqs, isBatch)
 			if errors.Is(err, ErrMethodNotWhitelisted) {
 				return nil, err
 			}
@@ -634,6 +692,18 @@ func (b *BackendGroup) Forward(ctx context.Context, rpcReqs []*RPCReq, isBatch b
 				)
 				continue
 			}
+		}
+
+		// re-apply overridden responses
+		for _, ov := range overriddenResponses {
+			if len(res) > 0 {
+				// insert ov.res at position ov.index
+				res = append(res[:ov.index], append([]*RPCRes{ov.res}, res[ov.index:]...)...)
+			} else {
+				res = append(res, ov.res)
+			}
+		}
+
 		return res, nil
 	}
 

proxyd/config.go

@@ -75,6 +75,9 @@ type BackendOptions struct {
 	MaxResponseSizeBytes        int64        `toml:"max_response_size_bytes"`
 	MaxRetries                  int          `toml:"max_retries"`
 	OutOfServiceSeconds         int          `toml:"out_of_service_seconds"`
+	MaxDegradedLatencyThreshold TOMLDuration `toml:"max_degraded_latency_threshold"`
+	MaxLatencyThreshold         TOMLDuration `toml:"max_latency_threshold"`
+	MaxErrorRateThreshold       float64      `toml:"max_error_rate_threshold"`
 }
 
 type BackendConfig struct {
@@ -95,8 +98,13 @@ type BackendsConfig map[string]*BackendConfig
 
 type BackendGroupConfig struct {
 	Backends []string `toml:"backends"`
+
 	ConsensusAware        bool   `toml:"consensus_aware"`
 	ConsensusAsyncHandler string `toml:"consensus_handler"`
+
+	ConsensusBanPeriod          TOMLDuration `toml:"consensus_ban_period"`
+	ConsensusMaxUpdateThreshold TOMLDuration `toml:"consensus_max_update_threshold"`
+	ConsensusMinPeerCount       int          `toml:"consensus_min_peer_count"`
 }
 
 type BackendGroupsConfig map[string]*BackendGroupConfig

proxyd/example.config.toml

@@ -44,6 +44,12 @@ max_response_size_bytes = 5242880
 max_retries = 3
 # Number of seconds to wait before trying an unhealthy backend again.
 out_of_service_seconds = 600
+# Maximum latency accepted to serve requests, default 10s
+max_latency_threshold = "30s"
+# Maximum latency accepted to serve requests before degraded, default 5s
+max_degraded_latency_threshold = "10s"
+# Maximum error rate accepted to serve requests, default 0.5 (i.e. 50%)
+max_error_rate_threshold = 0.3
 
 [backends]
 # A map of backends by name.
@@ -78,6 +84,14 @@ max_ws_conns = 1
 [backend_groups]
 [backend_groups.main]
 backends = ["infura"]
+# Enable consensus awareness for backend group, making it act as a load balancer, default false
+# consensus_aware = true
+# Period in which the backend wont serve requests if banned, default 5m
+# consensus_ban_period = "1m"
+# Maximum delay for update the backend, default 30s
+# consensus_max_update_threshold = "20s"
+# Minimum peer count, default 3
+# consensus_min_peer_count = 4
 
 [backend_groups.alchemy]
 backends = ["alchemy"]

proxyd/integration_tests/consensus_test.go

@@ -433,6 +433,184 @@ func TestConsensus(t *testing.T) {
 		require.Equal(t, len(node1.Requests()), 0, msg)
 		require.Equal(t, len(node2.Requests()), 10, msg)
 	})
+
+	t.Run("rewrite response of eth_blockNumber", func(t *testing.T) {
+		h1.ResetOverrides()
+		h2.ResetOverrides()
+		node1.Reset()
+		node2.Reset()
+		bg.Consensus.Unban()
+
+		// establish the consensus
+
+		h1.AddOverride(&ms.MethodTemplate{
+			Method:   "eth_getBlockByNumber",
+			Block:    "latest",
+			Response: buildGetBlockResponse("0x2", "hash2"),
+		})
+		h2.AddOverride(&ms.MethodTemplate{
+			Method:   "eth_getBlockByNumber",
+			Block:    "latest",
+			Response: buildGetBlockResponse("0x2", "hash2"),
+		})
+
+		for _, be := range bg.Backends {
+			bg.Consensus.UpdateBackend(ctx, be)
+		}
+		bg.Consensus.UpdateBackendGroupConsensus(ctx)
+
+		totalRequests := len(node1.Requests()) + len(node2.Requests())
+
+		require.Equal(t, 2, len(bg.Consensus.GetConsensusGroup()))
+
+		// pretend backends advanced in consensus, but we are still serving the latest value of the consensus
+		// until it gets updated again
+
+		h1.AddOverride(&ms.MethodTemplate{
+			Method:   "eth_getBlockByNumber",
+			Block:    "latest",
+			Response: buildGetBlockResponse("0x3", "hash3"),
+		})
+		h2.AddOverride(&ms.MethodTemplate{
+			Method:   "eth_getBlockByNumber",
+			Block:    "latest",
+			Response: buildGetBlockResponse("0x3", "hash3"),
+		})
+
+		resRaw, statusCode, err := client.SendRPC("eth_blockNumber", nil)
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+
+		var jsonMap map[string]interface{}
+		err = json.Unmarshal(resRaw, &jsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "0x2", jsonMap["result"])
+
+		// no extra request hit the backends
+		require.Equal(t, totalRequests, len(node1.Requests())+len(node2.Requests()))
+	})
+
+	t.Run("rewrite request of eth_getBlockByNumber", func(t *testing.T) {
+		h1.ResetOverrides()
+		h2.ResetOverrides()
+		bg.Consensus.Unban()
+
+		// establish the consensus and ban node2 for now
+		h1.AddOverride(&ms.MethodTemplate{
+			Method:   "eth_getBlockByNumber",
+			Block:    "latest",
+			Response: buildGetBlockResponse("0x2", "hash2"),
+		})
+		h2.AddOverride(&ms.MethodTemplate{
+			Method:   "net_peerCount",
+			Block:    "",
+			Response: buildPeerCountResponse(1),
+		})
+
+		for _, be := range bg.Backends {
+			bg.Consensus.UpdateBackend(ctx, be)
+		}
+		bg.Consensus.UpdateBackendGroupConsensus(ctx)
+
+		require.Equal(t, 1, len(bg.Consensus.GetConsensusGroup()))
+
+		node1.Reset()
+
+		_, statusCode, err := client.SendRPC("eth_getBlockByNumber", []interface{}{"latest"})
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+
+		var jsonMap map[string]interface{}
+		err = json.Unmarshal(node1.Requests()[0].Body, &jsonMap)
+		require.NoError(t, err)
+		require.Equal(t, "0x2", jsonMap["params"].([]interface{})[0])
+	})
+
+	t.Run("rewrite request of eth_getBlockByNumber - out of range", func(t *testing.T) {
+		h1.ResetOverrides()
+		h2.ResetOverrides()
+		bg.Consensus.Unban()
+
+		// establish the consensus and ban node2 for now
+		h1.AddOverride(&ms.MethodTemplate{
+			Method:   "eth_getBlockByNumber",
+			Block:    "latest",
+			Response: buildGetBlockResponse("0x2", "hash2"),
+		})
+		h2.AddOverride(&ms.MethodTemplate{
+			Method:   "net_peerCount",
+			Block:    "",
+			Response: buildPeerCountResponse(1),
+		})
+
+		for _, be := range bg.Backends {
+			bg.Consensus.UpdateBackend(ctx, be)
+		}
+		bg.Consensus.UpdateBackendGroupConsensus(ctx)
+
+		require.Equal(t, 1, len(bg.Consensus.GetConsensusGroup()))
+
+		node1.Reset()
+
+		resRaw, statusCode, err := client.SendRPC("eth_getBlockByNumber", []interface{}{"0x10"})
+		require.NoError(t, err)
+		require.Equal(t, 400, statusCode)
+
+		var jsonMap map[string]interface{}
+		err = json.Unmarshal(resRaw, &jsonMap)
+		require.NoError(t, err)
+		require.Equal(t, -32019, int(jsonMap["error"].(map[string]interface{})["code"].(float64)))
+		require.Equal(t, "block is out of range", jsonMap["error"].(map[string]interface{})["message"])
+	})
+
+	t.Run("batched rewrite", func(t *testing.T) {
+		h1.ResetOverrides()
+		h2.ResetOverrides()
+		bg.Consensus.Unban()
+
+		// establish the consensus and ban node2 for now
+		h1.AddOverride(&ms.MethodTemplate{
+			Method:   "eth_getBlockByNumber",
+			Block:    "latest",
+			Response: buildGetBlockResponse("0x2", "hash2"),
+		})
+		h2.AddOverride(&ms.MethodTemplate{
+			Method:   "net_peerCount",
+			Block:    "",
+			Response: buildPeerCountResponse(1),
+		})
+
+		for _, be := range bg.Backends {
+			bg.Consensus.UpdateBackend(ctx, be)
+		}
+		bg.Consensus.UpdateBackendGroupConsensus(ctx)
+
+		require.Equal(t, 1, len(bg.Consensus.GetConsensusGroup()))
+
+		node1.Reset()
+
+		resRaw, statusCode, err := client.SendBatchRPC(
+			NewRPCReq("1", "eth_getBlockByNumber", []interface{}{"latest"}),
+			NewRPCReq("2", "eth_getBlockByNumber", []interface{}{"0x10"}),
+			NewRPCReq("3", "eth_getBlockByNumber", []interface{}{"0x1"}))
+		require.NoError(t, err)
+		require.Equal(t, 200, statusCode)
+
+		var jsonMap []map[string]interface{}
+		err = json.Unmarshal(resRaw, &jsonMap)
+		require.NoError(t, err)
+		require.Equal(t, 3, len(jsonMap))
+
+		// rewrite latest to 0x2
+		require.Equal(t, "0x2", jsonMap[0]["result"].(map[string]interface{})["number"])
+
+		// out of bounds for block 0x10
+		require.Equal(t, -32019, int(jsonMap[1]["error"].(map[string]interface{})["code"].(float64)))
+		require.Equal(t, "block is out of range", jsonMap[1]["error"].(map[string]interface{})["message"])
+
+		// dont rewrite for 0x1
+		require.Equal(t, "0x1", jsonMap[2]["result"].(map[string]interface{})["number"])
+	})
 }
 
 func backend(bg *proxyd.BackendGroup, name string) *proxyd.Backend {

proxyd/integration_tests/testdata/consensus.toml

@@ -16,6 +16,9 @@ rpc_url = "$NODE2_URL"
 backends = ["node1", "node2"]
 consensus_aware = true
 consensus_handler = "noop" # allow more control over the consensus poller for tests
+consensus_ban_period = "1m"
+consensus_max_update_threshold = "2m"
+consensus_min_peer_count = 4
 
 [rpc_method_mappings]
 eth_call = "node"

proxyd/proxyd.go

@@ -123,6 +123,15 @@ func Start(config *Config) (*Server, func(), error) {
 		if config.BackendOptions.OutOfServiceSeconds != 0 {
 			opts = append(opts, WithOutOfServiceDuration(secondsToDuration(config.BackendOptions.OutOfServiceSeconds)))
 		}
+		if config.BackendOptions.MaxDegradedLatencyThreshold > 0 {
+			opts = append(opts, WithMaxDegradedLatencyThreshold(time.Duration(config.BackendOptions.MaxDegradedLatencyThreshold)))
+		}
+		if config.BackendOptions.MaxLatencyThreshold > 0 {
+			opts = append(opts, WithMaxLatencyThreshold(time.Duration(config.BackendOptions.MaxLatencyThreshold)))
+		}
+		if config.BackendOptions.MaxErrorRateThreshold > 0 {
+			opts = append(opts, WithMaxErrorRateThreshold(config.BackendOptions.MaxErrorRateThreshold))
+		}
 		if cfg.MaxRPS != 0 {
 			opts = append(opts, WithMaxRPS(cfg.MaxRPS))
 		}
@@ -148,6 +157,7 @@ func Start(config *Config) (*Server, func(), error) {
 			opts = append(opts, WithStrippedTrailingXFF())
 		}
 		opts = append(opts, WithProxydIP(os.Getenv("PROXYD_IP")))
+
 		back := NewBackend(name, rpcURL, wsURL, lim, rpcRequestSemaphore, opts...)
 		backendNames = append(backendNames, name)
 		backendsByName[name] = back
@@ -302,14 +312,25 @@ func Start(config *Config) (*Server, func(), error) {
 	}
 
 	for bgName, bg := range backendGroups {
-		if config.BackendGroups[bgName].ConsensusAware {
+		bgcfg := config.BackendGroups[bgName]
+		if bgcfg.ConsensusAware {
 			log.Info("creating poller for consensus aware backend_group", "name", bgName)
 
 			copts := make([]ConsensusOpt, 0)
 
-			if config.BackendGroups[bgName].ConsensusAsyncHandler == "noop" {
+			if bgcfg.ConsensusAsyncHandler == "noop" {
 				copts = append(copts, WithAsyncHandler(NewNoopAsyncHandler()))
 			}
+			if bgcfg.ConsensusBanPeriod > 0 {
+				copts = append(copts, WithBanPeriod(time.Duration(bgcfg.ConsensusBanPeriod)))
+			}
+			if bgcfg.ConsensusMaxUpdateThreshold > 0 {
+				copts = append(copts, WithMaxUpdateThreshold(time.Duration(bgcfg.ConsensusMaxUpdateThreshold)))
+			}
+			if bgcfg.ConsensusMinPeerCount > 0 {
+				copts = append(copts, WithMinPeerCount(uint64(bgcfg.ConsensusMinPeerCount)))
+			}
+
 			cp := NewConsensusPoller(bg, copts...)
 			bg.Consensus = cp
 		}

proxyd/rewriter.go

+package proxyd
+
+import (
+	"encoding/json"
+	"errors"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+type RewriteContext struct {
+	latest hexutil.Uint64
+}
+
+type RewriteResult uint8
+
+const (
+	// RewriteNone means request should be forwarded as-is
+	RewriteNone RewriteResult = iota
+
+	// RewriteOverrideError means there was an error attempting to rewrite
+	RewriteOverrideError
+
+	// RewriteOverrideRequest means the modified request should be forwarded to the backend
+	RewriteOverrideRequest
+
+	// RewriteOverrideResponse means to skip calling the backend and serve the overridden response
+	RewriteOverrideResponse
+)
+
+var (
+	ErrRewriteBlockOutOfRange = errors.New("block is out of range")
+)
+
+// RewriteTags modifies the request and the response based on block tags
+func RewriteTags(rctx RewriteContext, req *RPCReq, res *RPCRes) (RewriteResult, error) {
+	rw, err := RewriteResponse(rctx, req, res)
+	if rw == RewriteOverrideResponse {
+		return rw, err
+	}
+	return RewriteRequest(rctx, req, res)
+}
+
+// RewriteResponse modifies the response object to comply with the rewrite context
+// after the method has been called at the backend
+// RewriteResult informs the decision of the rewrite
+func RewriteResponse(rctx RewriteContext, req *RPCReq, res *RPCRes) (RewriteResult, error) {
+	switch req.Method {
+	case "eth_blockNumber":
+		res.Result = rctx.latest
+		return RewriteOverrideResponse, nil
+	}
+	return RewriteNone, nil
+}
+
+// RewriteRequest modifies the request object to comply with the rewrite context
+// before the method has been called at the backend
+// it returns false if nothing was changed
+func RewriteRequest(rctx RewriteContext, req *RPCReq, res *RPCRes) (RewriteResult, error) {
+	switch req.Method {
+	case "eth_getLogs",
+		"eth_newFilter":
+		return rewriteRange(rctx, req, res, 0)
+	case "eth_getBalance",
+		"eth_getCode",
+		"eth_getTransactionCount",
+		"eth_call":
+		return rewriteParam(rctx, req, res, 1)
+	case "eth_getStorageAt":
+		return rewriteParam(rctx, req, res, 2)
+	case "eth_getBlockTransactionCountByNumber",
+		"eth_getUncleCountByBlockNumber",
+		"eth_getBlockByNumber",
+		"eth_getTransactionByBlockNumberAndIndex",
+		"eth_getUncleByBlockNumberAndIndex":
+		return rewriteParam(rctx, req, res, 0)
+	}
+	return RewriteNone, nil
+}
+
+func rewriteParam(rctx RewriteContext, req *RPCReq, res *RPCRes, pos int) (RewriteResult, error) {
+	var p []interface{}
+	err := json.Unmarshal(req.Params, &p)
+	if err != nil {
+		return RewriteOverrideError, err
+	}
+
+	if len(p) <= pos {
+		p = append(p, "latest")
+	}
+
+	val, rw, err := rewriteTag(rctx, p[pos].(string))
+	if err != nil {
+		return RewriteOverrideError, err
+	}
+
+	if rw {
+		p[pos] = val
+		paramRaw, err := json.Marshal(p)
+		if err != nil {
+			return RewriteOverrideError, err
+		}
+		req.Params = paramRaw
+		return RewriteOverrideRequest, nil
+	}
+	return RewriteNone, nil
+}
+
+func rewriteRange(rctx RewriteContext, req *RPCReq, res *RPCRes, pos int) (RewriteResult, error) {
+	var p []map[string]interface{}
+	err := json.Unmarshal(req.Params, &p)
+	if err != nil {
+		return RewriteOverrideError, err
+	}
+
+	modifiedFrom, err := rewriteTagMap(rctx, p[pos], "fromBlock")
+	if err != nil {
+		return RewriteOverrideError, err
+	}
+
+	modifiedTo, err := rewriteTagMap(rctx, p[pos], "toBlock")
+	if err != nil {
+		return RewriteOverrideError, err
+	}
+
+	// if any of the fields the request have been changed, re-marshal the params
+	if modifiedFrom || modifiedTo {
+		paramsRaw, err := json.Marshal(p)
+		req.Params = paramsRaw
+		if err != nil {
+			return RewriteOverrideError, err
+		}
+		return RewriteOverrideRequest, nil
+	}
+
+	return RewriteNone, nil
+}
+
+func rewriteTagMap(rctx RewriteContext, m map[string]interface{}, key string) (bool, error) {
+	if m[key] == nil || m[key] == "" {
+		return false, nil
+	}
+
+	current, ok := m[key].(string)
+	if !ok {
+		return false, errors.New("expected string")
+	}
+
+	val, rw, err := rewriteTag(rctx, current)
+	if err != nil {
+		return false, err
+	}
+	if rw {
+		m[key] = val
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func rewriteTag(rctx RewriteContext, current string) (string, bool, error) {
+	if current == "latest" {
+		return rctx.latest.String(), true, nil
+	} else if strings.HasPrefix(current, "0x") {
+		decode, err := hexutil.DecodeUint64(current)
+		if err != nil {
+			return current, false, err
+		}
+		b := hexutil.Uint64(decode)
+		if b > rctx.latest {
+			return "", false, ErrRewriteBlockOutOfRange
+		}
+	}
+	return current, false, nil
+}

proxyd/rewriter_test.go

+package proxyd
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/stretchr/testify/require"
+)
+
+type args struct {
+	rctx RewriteContext
+	req  *RPCReq
+	res  *RPCRes
+}
+
+type rewriteTest struct {
+	name        string
+	args        args
+	expected    RewriteResult
+	expectedErr error
+	check       func(*testing.T, args)
+}
+
+func TestRewriteRequest(t *testing.T) {
+	tests := []rewriteTest{
+		/* range scoped */
+		{
+			name: "eth_getLogs fromBlock latest",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": "latest"}})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []map[string]interface{}
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, hexutil.Uint64(100).String(), p[0]["fromBlock"])
+			},
+		},
+		{
+			name: "eth_getLogs fromBlock within range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": hexutil.Uint64(55).String()}})},
+				res:  nil,
+			},
+			expected: RewriteNone,
+			check: func(t *testing.T, args args) {
+				var p []map[string]interface{}
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, hexutil.Uint64(55).String(), p[0]["fromBlock"])
+			},
+		},
+		{
+			name: "eth_getLogs fromBlock out of range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": hexutil.Uint64(111).String()}})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteBlockOutOfRange,
+		},
+		{
+			name: "eth_getLogs toBlock latest",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"toBlock": "latest"}})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []map[string]interface{}
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, hexutil.Uint64(100).String(), p[0]["toBlock"])
+			},
+		},
+		{
+			name: "eth_getLogs toBlock within range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"toBlock": hexutil.Uint64(55).String()}})},
+				res:  nil,
+			},
+			expected: RewriteNone,
+			check: func(t *testing.T, args args) {
+				var p []map[string]interface{}
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, hexutil.Uint64(55).String(), p[0]["toBlock"])
+			},
+		},
+		{
+			name: "eth_getLogs toBlock out of range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"toBlock": hexutil.Uint64(111).String()}})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteBlockOutOfRange,
+		},
+		{
+			name: "eth_getLogs fromBlock, toBlock latest",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": "latest", "toBlock": "latest"}})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []map[string]interface{}
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, hexutil.Uint64(100).String(), p[0]["fromBlock"])
+				require.Equal(t, hexutil.Uint64(100).String(), p[0]["toBlock"])
+			},
+		},
+		{
+			name: "eth_getLogs fromBlock, toBlock within range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": hexutil.Uint64(55).String(), "toBlock": hexutil.Uint64(77).String()}})},
+				res:  nil,
+			},
+			expected: RewriteNone,
+			check: func(t *testing.T, args args) {
+				var p []map[string]interface{}
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, hexutil.Uint64(55).String(), p[0]["fromBlock"])
+				require.Equal(t, hexutil.Uint64(77).String(), p[0]["toBlock"])
+			},
+		},
+		{
+			name: "eth_getLogs fromBlock, toBlock out of range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": hexutil.Uint64(111).String(), "toBlock": hexutil.Uint64(222).String()}})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteBlockOutOfRange,
+		},
+		/* default block parameter */
+		{
+			name: "eth_getCode omit block, should add",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getCode", Params: mustMarshalJSON([]string{"0x123"})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 2, len(p))
+				require.Equal(t, "0x123", p[0])
+				require.Equal(t, hexutil.Uint64(100).String(), p[1])
+			},
+		},
+		{
+			name: "eth_getCode latest",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getCode", Params: mustMarshalJSON([]string{"0x123", "latest"})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 2, len(p))
+				require.Equal(t, "0x123", p[0])
+				require.Equal(t, hexutil.Uint64(100).String(), p[1])
+			},
+		},
+		{
+			name: "eth_getCode within range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getCode", Params: mustMarshalJSON([]string{"0x123", hexutil.Uint64(55).String()})},
+				res:  nil,
+			},
+			expected: RewriteNone,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 2, len(p))
+				require.Equal(t, "0x123", p[0])
+				require.Equal(t, hexutil.Uint64(55).String(), p[1])
+			},
+		},
+		{
+			name: "eth_getCode out of range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getCode", Params: mustMarshalJSON([]string{"0x123", hexutil.Uint64(111).String()})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteBlockOutOfRange,
+		},
+		/* default block parameter, at position 2 */
+		{
+			name: "eth_getStorageAt omit block, should add",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getStorageAt", Params: mustMarshalJSON([]string{"0x123", "5"})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 3, len(p))
+				require.Equal(t, "0x123", p[0])
+				require.Equal(t, "5", p[1])
+				require.Equal(t, hexutil.Uint64(100).String(), p[2])
+			},
+		},
+		{
+			name: "eth_getStorageAt latest",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getStorageAt", Params: mustMarshalJSON([]string{"0x123", "5", "latest"})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 3, len(p))
+				require.Equal(t, "0x123", p[0])
+				require.Equal(t, "5", p[1])
+				require.Equal(t, hexutil.Uint64(100).String(), p[2])
+			},
+		},
+		{
+			name: "eth_getStorageAt within range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getStorageAt", Params: mustMarshalJSON([]string{"0x123", "5", hexutil.Uint64(55).String()})},
+				res:  nil,
+			},
+			expected: RewriteNone,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 3, len(p))
+				require.Equal(t, "0x123", p[0])
+				require.Equal(t, "5", p[1])
+				require.Equal(t, hexutil.Uint64(55).String(), p[2])
+			},
+		},
+		{
+			name: "eth_getStorageAt out of range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getStorageAt", Params: mustMarshalJSON([]string{"0x123", "5", hexutil.Uint64(111).String()})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteBlockOutOfRange,
+		},
+		/* default block parameter, at position 0 */
+		{
+			name: "eth_getBlockByNumber omit block, should add",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getBlockByNumber", Params: mustMarshalJSON([]string{})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 1, len(p))
+				require.Equal(t, hexutil.Uint64(100).String(), p[0])
+			},
+		},
+		{
+			name: "eth_getBlockByNumber latest",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getBlockByNumber", Params: mustMarshalJSON([]string{"latest"})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 1, len(p))
+				require.Equal(t, hexutil.Uint64(100).String(), p[0])
+			},
+		},
+		{
+			name: "eth_getBlockByNumber within range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getBlockByNumber", Params: mustMarshalJSON([]string{hexutil.Uint64(55).String()})},
+				res:  nil,
+			},
+			expected: RewriteNone,
+			check: func(t *testing.T, args args) {
+				var p []string
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, 1, len(p))
+				require.Equal(t, hexutil.Uint64(55).String(), p[0])
+			},
+		},
+		{
+			name: "eth_getBlockByNumber out of range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_getBlockByNumber", Params: mustMarshalJSON([]string{hexutil.Uint64(111).String()})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteBlockOutOfRange,
+		},
+	}
+
+	// generalize tests for other methods with same interface and behavior
+	tests = generalize(tests, "eth_getLogs", "eth_newFilter")
+	tests = generalize(tests, "eth_getCode", "eth_getBalance")
+	tests = generalize(tests, "eth_getCode", "eth_getTransactionCount")
+	tests = generalize(tests, "eth_getCode", "eth_call")
+	tests = generalize(tests, "eth_getBlockByNumber", "eth_getBlockTransactionCountByNumber")
+	tests = generalize(tests, "eth_getBlockByNumber", "eth_getUncleCountByBlockNumber")
+	tests = generalize(tests, "eth_getBlockByNumber", "eth_getTransactionByBlockNumberAndIndex")
+	tests = generalize(tests, "eth_getBlockByNumber", "eth_getUncleByBlockNumberAndIndex")
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := RewriteRequest(tt.args.rctx, tt.args.req, tt.args.res)
+			if result != RewriteOverrideError {
+				require.Nil(t, err)
+				require.Equal(t, tt.expected, result)
+			} else {
+				require.Equal(t, tt.expectedErr, err)
+			}
+			if tt.check != nil {
+				tt.check(t, tt.args)
+			}
+		})
+	}
+}
+
+func generalize(tests []rewriteTest, baseMethod string, generalizedMethod string) []rewriteTest {
+	newCases := make([]rewriteTest, 0)
+	for _, t := range tests {
+		if t.args.req.Method == baseMethod {
+			newName := strings.Replace(t.name, baseMethod, generalizedMethod, -1)
+			var req *RPCReq
+			var res *RPCRes
+
+			if t.args.req != nil {
+				req = &RPCReq{
+					JSONRPC: t.args.req.JSONRPC,
+					Method:  generalizedMethod,
+					Params:  t.args.req.Params,
+					ID:      t.args.req.ID,
+				}
+			}
+
+			if t.args.res != nil {
+				res = &RPCRes{
+					JSONRPC: t.args.res.JSONRPC,
+					Result:  t.args.res.Result,
+					Error:   t.args.res.Error,
+					ID:      t.args.res.ID,
+				}
+			}
+			newCases = append(newCases, rewriteTest{
+				name: newName,
+				args: args{
+					rctx: t.args.rctx,
+					req:  req,
+					res:  res,
+				},
+				expected:    t.expected,
+				expectedErr: t.expectedErr,
+				check:       t.check,
+			})
+		}
+	}
+	return append(tests, newCases...)
+}
+
+func TestRewriteResponse(t *testing.T) {
+	type args struct {
+		rctx RewriteContext
+		req  *RPCReq
+		res  *RPCRes
+	}
+	tests := []struct {
+		name     string
+		args     args
+		expected RewriteResult
+		check    func(*testing.T, args)
+	}{
+		{
+			name: "eth_blockNumber latest",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100)},
+				req:  &RPCReq{Method: "eth_blockNumber"},
+				res:  &RPCRes{Result: hexutil.Uint64(200)},
+			},
+			expected: RewriteOverrideResponse,
+			check: func(t *testing.T, args args) {
+				require.Equal(t, args.res.Result, hexutil.Uint64(100))
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := RewriteResponse(tt.args.rctx, tt.args.req, tt.args.res)
+			require.Nil(t, err)
+			require.Equal(t, tt.expected, result)
+			if tt.check != nil {
+				tt.check(t, tt.args)
+			}
+		})
+	}
+}

proxyd/tools/mockserver/handler/handler.go

@@ -6,6 +6,9 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"strings"
+
+	"github.com/ethereum-optimism/optimism/proxyd"
 
 	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
@@ -46,12 +49,6 @@ func (mh *MockedHandler) Handler(w http.ResponseWriter, req *http.Request) {
 		fmt.Printf("error reading request: %v\n", err)
 	}
 
-	var j map[string]interface{}
-	err = json.Unmarshal(body, &j)
-	if err != nil {
-		fmt.Printf("error reading request: %v\n", err)
-	}
-
 	var template []*MethodTemplate
 	if mh.Autoload {
 		template = append(template, mh.LoadFromFile(mh.AutoloadFile)...)
@@ -60,24 +57,52 @@ func (mh *MockedHandler) Handler(w http.ResponseWriter, req *http.Request) {
 		template = append(template, mh.Overrides...)
 	}
 
-	method := j["method"]
+	batched := proxyd.IsBatch(body)
+	var requests []map[string]interface{}
+	if batched {
+		err = json.Unmarshal(body, &requests)
+		if err != nil {
+			fmt.Printf("error reading request: %v\n", err)
+		}
+	} else {
+		var j map[string]interface{}
+		err = json.Unmarshal(body, &j)
+		if err != nil {
+			fmt.Printf("error reading request: %v\n", err)
+		}
+		requests = append(requests, j)
+	}
+
+	var responses []string
+	for _, r := range requests {
+		method := r["method"]
 		block := ""
 		if method == "eth_getBlockByNumber" {
-		block = (j["params"].([]interface{})[0]).(string)
+			block = (r["params"].([]interface{})[0]).(string)
 		}
 
-	var selectedResponse *string
+		var selectedResponse string
 		for _, r := range template {
 			if r.Method == method && r.Block == block {
-			selectedResponse = &r.Response
+				selectedResponse = r.Response
+			}
 		}
+		if selectedResponse != "" {
+			responses = append(responses, selectedResponse)
 		}
-	if selectedResponse != nil {
-		_, err := fmt.Fprintf(w, *selectedResponse)
+	}
+
+	resBody := ""
+	if batched {
+		resBody = "[" + strings.Join(responses, ",") + "]"
+	} else {
+		resBody = responses[0]
+	}
+
+	_, err = fmt.Fprint(w, resBody)
 	if err != nil {
 		fmt.Printf("error writing response: %v\n", err)
 	}
-	}
 }
 
 func (mh *MockedHandler) LoadFromFile(file string) []*MethodTemplate {