fix: Handle NEAR nested error strings as valid JSON-RPC success

NEAR's JSON-RPC returns execution errors as strings nested inside the
result object: {"result":{"error":"wasm execution failed..."},"id":1}

The heuristic was detecting "error" via substring match, seeing both
"result" and "error" present, and flagging it as jsonrpc_both_result_and_error
(malformed). This triggered retry, reputation penalty, and circuit breaking
for all NEAR suppliers returning wasm execution errors.

Fix: when both "result" and "error" are found, check if "error" is a
top-level JSON-RPC error object ("error": {) or a nested string
("error": "..."). Only flag as malformed if it's a top-level error object.
Uses whitespace-tolerant scanning consistent with emptyResultType().

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: oten91

qos/heuristic/analyzer_test.go

@@ -207,6 +207,18 @@ func TestProtocolAnalysis_JSONRPC(t *testing.T) {
 			expectedRetry:  true,
 			expectedReason: "jsonrpc_both_result_and_error",
 		},
+		{
+			name:           "NEAR result with nested error string - valid success (not malformed)",
+			response:       []byte(`{"jsonrpc":"2.0","result":{"block_hash":"kkJU2quYwNQ","block_height":192983668,"error":"wasm execution failed with error: HostError(GuestPanic { panic_msg: \"panicked at E102\" })","logs":[]},"id":20}`),
+			expectedRetry:  false,
+			expectedReason: "jsonrpc_success",
+		},
+		{
+			name:           "NEAR result with nested error string - simple",
+			response:       []byte(`{"jsonrpc":"2.0","id":1,"result":{"error":"some error message","logs":[]}}`),
+			expectedRetry:  false,
+			expectedReason: "jsonrpc_success",
+		},
 		{
 			name:           "Error without jsonrpc version - suspicious",
 			response:       []byte(`{"error":"Bad Gateway"}`),

qos/heuristic/protocol.go

@@ -340,14 +340,29 @@ func analyzeJSONRPC(prefix []byte, fullLength int, rpcType sharedtypes.RPCType,
 		}
 	}
 
-	// Case 3: Has BOTH "result" and "error" - malformed (violates JSON-RPC spec)
+	// Case 3: Has BOTH "result" and "error"
+	// Standard JSON-RPC spec forbids both, but some protocols (e.g., NEAR) nest an
+	// "error" string inside the result object for execution failures:
+	//   {"jsonrpc":"2.0","result":{"error":"wasm execution failed...","logs":[]},"id":1}
+	// This is a valid success response — NOT malformed. Only flag if the "error" is a
+	// top-level JSON-RPC error object (i.e., "error" followed by `:` and `{`).
 	if hasResult && hasError {
+		if isTopLevelJSONRPCError(prefix) {
+			return AnalysisResult{
+				ShouldRetry: true,
+				Confidence:  0.95,
+				Reason:      "jsonrpc_both_result_and_error",
+				Structure:   StructureValid,
+				Details:     "JSON-RPC response has both result and error (malformed)",
+			}
+		}
+		// "error" is nested inside result (e.g., NEAR's result.error string) — treat as success
 		return AnalysisResult{
-			ShouldRetry: true,
-			Confidence:  0.95,
-			Reason:      "jsonrpc_both_result_and_error",
+			ShouldRetry: false,
+			Confidence:  0.0,
+			Reason:      "jsonrpc_success",
 			Structure:   StructureValid,
-			Details:     "JSON-RPC response has both result and error (malformed)",
+			Details:     "JSON-RPC response contains result field with nested error string",
 		}
 	}
 
@@ -557,6 +572,29 @@ func emptyResultType(prefix []byte) emptyResultKind {
 	return notEmpty
 }
 
+// isTopLevelJSONRPCError checks if the "error" field in the prefix is a top-level
+// JSON-RPC error object (i.e., "error": {), as opposed to a nested error string
+// inside the result object (e.g., NEAR's "result":{"error":"wasm execution failed..."}).
+// Uses whitespace-tolerant scanning, same approach as emptyResultType.
+func isTopLevelJSONRPCError(prefix []byte) bool {
+	idx := bytes.Index(prefix, jsonrpcErrorField)
+	if idx < 0 {
+		return false
+	}
+
+	// Skip past "error" and find the colon
+	after := prefix[idx+len(jsonrpcErrorField):]
+	after = bytes.TrimLeft(after, " \t\n\r")
+	if len(after) == 0 || after[0] != ':' {
+		return false
+	}
+	after = bytes.TrimLeft(after[1:], " \t\n\r")
+
+	// Top-level JSON-RPC error is an object: "error": { ... }
+	// Nested error string is: "error": "string"
+	return len(after) > 0 && after[0] == '{'
+}
+
 // IsJSONRPCLikeSuccess provides a quick check for JSON-RPC success.
 // This is a simplified version for callers who just need a boolean.
 func IsJSONRPCLikeSuccess(prefix []byte) bool {