feat: proxyd update consensus mode out of range requests to be api-spec compliant (#552)

* fix(proxyd): don't return error for out-of-range block requests

* feat: update proxyd consensus mode rewriter to provide json rpc compliant responses on out of range requests

---------

Co-authored-by: Sebastian Stammler <seb@oplabs.co>

Author: jelias2

proxyd/backend.go

@@ -97,12 +97,6 @@ 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,
-	}
-
 	ErrRequestBodyTooLarge = &RPCErr{
 		Code:          JSONRPCErrorInternal - 21,
 		Message:       "request body too large",
@@ -1795,7 +1789,37 @@ func (bg *BackendGroup) OverwriteConsensusResponses(rpcReqs []*RPCReq, overridde
 				res:   &res,
 			})
 			if errors.Is(err, ErrRewriteBlockOutOfRange) {
-				res.Error = ErrBlockOutOfRange
+				// Return spec-compliant response for out-of-range blocks
+				// instead of forwarding to backend (fail-fast)
+				log.Debug(
+					"returning spec-compliant response for out-of-range block request",
+					"method", req.Method,
+					"req_id", req.ID,
+				)
+				switch req.Method {
+				case "eth_getBlockByNumber",
+					"eth_getBlockByHash",
+					"eth_getBlockReceipts",
+					"eth_getBlockTransactionCountByNumber",
+					"eth_getUncleCountByBlockNumber",
+					"eth_getTransactionByBlockNumberAndIndex",
+					"eth_getUncleByBlockNumberAndIndex",
+					"debug_getRawReceipts",
+					"consensus_getReceipts":
+					res.Result = json.RawMessage("null")
+				case "eth_getLogs":
+					res.Result = json.RawMessage("[]")
+				case "eth_getCode":
+					res.Result = json.RawMessage("\"0x\"")
+				case "eth_getStorageAt":
+					res.Result = json.RawMessage("\"0x0000000000000000000000000000000000000000000000000000000000000000\"")
+				case "eth_getBalance",
+					"eth_getTransactionCount":
+					res.Result = json.RawMessage("\"0x0\"")
+				default:
+					// For unknown methods, return null
+					res.Result = json.RawMessage("null")
+				}
 			} else if errors.Is(err, ErrRewriteRangeTooLarge) {
 				res.Error = ErrInvalidParams(
 					fmt.Sprintf("block range greater than %d max", rctx.maxBlockRange),

proxyd/integration_tests/consensus_test.go

@@ -752,19 +752,24 @@ func TestConsensus(t *testing.T) {
 		require.Equal(t, "0xe1", jsonMap["params"].([]interface{})[0])
 	})
 
-	t.Run("rewrite request of eth_getBlockByNumber - out of range", func(t *testing.T) {
+	t.Run("rewrite request of eth_getBlockByNumber - out of range returns null without hitting backend", func(t *testing.T) {
 		reset()
 		useOnlyNode1()
 
+		// the request for a future block should return null directly from proxyd
+		// per the Ethereum JSON-RPC spec, without hitting the backend (fail-fast)
 		resRaw, statusCode, err := client.SendRPC("eth_getBlockByNumber", []interface{}{"0x300"})
 		require.NoError(t, err)
-		require.Equal(t, 400, statusCode)
+		require.Equal(t, 200, 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"])
+		require.Nil(t, jsonMap["result"])
+		require.Nil(t, jsonMap["error"])
+
+		// verify backend was NOT called (fail-fast)
+		require.Equal(t, 0, len(nodes["node1"].mockBackend.Requests()))
 	})
 
 	t.Run("batched rewrite", func(t *testing.T) {
@@ -786,9 +791,9 @@ func TestConsensus(t *testing.T) {
 		// rewrite latest to 0x101
 		require.Equal(t, "0x101", jsonMap[0]["result"].(map[string]interface{})["number"])
 
-		// out of bounds for block 0x102
-		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"])
+		// block 0x102 is beyond latest (0x101) so returns null (fail-fast, spec-compliant)
+		require.Nil(t, jsonMap[1]["result"])
+		require.Nil(t, jsonMap[1]["error"])
 
 		// dont rewrite for 0xe1
 		require.Equal(t, "0xe1", jsonMap[2]["result"].(map[string]interface{})["number"])