Make RpcResponse provide the resopnse payload directly (#3185)

This PR reverts some of the changes in the previous stack by making the following key change:

```ts
// Before.
type RpcResponse<TResponse = unknown> = {
    readonly json: () => Promise<TResponse>;
    readonly text: () => Promise<string>;
};

// After.
type RpcResponse<TResponse = unknown> = TResponse;
```

This is because we no longer believe that it is the responsibility of the RPC API to affect the response as text or JSON. This aspect should be encapsulated by the RPC Transport layer, meaning any custom JSON parsing/stringifying will need to be done at the RPC Transport layer.

Note that, we could simply delete the `RpcResponse` type since it returns its type parameter directly but keeping it makes the code clearer as we will use `RpcResponse` instead of `unknown` everywhere in the codebase.

.changeset/light-bugs-compare.md

@@ -2,4 +2,4 @@
 '@solana/rpc-spec': patch
 ---
 
-Add new `RpcRequest` and `RpcResponse` types with `RpcRequestTransformer`, `RpcResponseTransformer` and `createJsonRpcResponseTransformer` functions
+Add new `RpcRequest` and `RpcResponse` types with `RpcRequestTransformer` and `RpcResponseTransformer` functions

packages/rpc-api/src/__tests__/get-health-test.ts

@@ -1,16 +1,9 @@
 import { SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NODE_UNHEALTHY, SolanaError } from '@solana/errors';
-import { createRpc, type Rpc, type RpcResponse } from '@solana/rpc-spec';
+import { createRpc, type Rpc } from '@solana/rpc-spec';
 
 import { createSolanaRpcApi, GetHealthApi } from '../index';
 import { createLocalhostSolanaRpc } from './__setup__';
 
-function createMockResponse<T>(jsonResponse: T): RpcResponse<T> {
-    return {
-        json: () => Promise.resolve(jsonResponse),
-        text: () => Promise.resolve(JSON.stringify(jsonResponse)),
-    };
-}
-
 describe('getHealth', () => {
     describe('when the node is healthy', () => {
         let rpc: Rpc<GetHealthApi>;
@@ -36,7 +29,7 @@ describe('getHealth', () => {
         beforeEach(() => {
             rpc = createRpc({
                 api: createSolanaRpcApi(),
-                transport: jest.fn().mockResolvedValue(createMockResponse({ error: errorObject })),
+                transport: jest.fn().mockResolvedValue({ error: errorObject }),
             });
         });
         it('returns an error message', async () => {

packages/rpc-spec/README.md

@@ -54,12 +54,7 @@ A function that accepts an `RpcRequest` and returns another `RpcRequest`. This a
 
 ### `RpcResponse`
 
-An object that represents the response from a JSON RPC server. It contains two asynchronous methods that can be used to access the response data:
-
--   `await response.json()`: Returns the data as a JSON object.
--   `await response.text()`: Returns the data, unparsed, as a JSON string.
-
-This allows the `RpcApi` to decide whether they want the parsed JSON object or the raw JSON string. Ultimately, the `json` method will be used by the `Rpc` to provide the final response to the caller.
+A type that represents the response from a JSON RPC server. This could be any sort of data which is why `RpcResponse` defaults to `unknown`. You may use a type parameter to specify the shape of the response — e.g. `RpcResponse<{ result: number }>`.
 
 ### `RpcResponseTransformer`
 
@@ -140,17 +135,3 @@ A config object with the following properties:
 
 -   `requestTransformer<T>(request: RpcRequest<T>): RpcRequest`: An optional function that transforms the `RpcRequest` before it is sent to the JSON RPC server.
 -   `responseTransformer<T>(response: RpcResponse, request: RpcRequest): RpcResponse<T>`: An optional function that transforms the `RpcResponse` before it is returned to the caller.
-
-### `createJsonRpcResponseTransformer(jsonTransformer)`
-
-Creates an `RpcResponseTransformer<T>` function from a function that transforms any JSON value to a value of type `T` by wrapping it in a `json` async function.
-
-```ts
-const getResultTransformer = createJsonRpcResponseTransformer((json: unknown): unknown => {
-    return (json as { result: unknown }).result;
-});
-```
-
-#### Arguments
-
--   `jsonTransformer: (json: unknown, request: RpcRequest) => T`: A function that transforms an unknown JSON value to a value of type `T`.

packages/rpc-spec/src/__tests__/rpc-test.ts

@@ -2,20 +2,12 @@ import { createRpcMessage } from '@solana/rpc-spec-types';
 
 import { createRpc, Rpc } from '../rpc';
 import { RpcApi, RpcApiRequestPlan } from '../rpc-api';
-import { createJsonRpcResponseTransformer, RpcResponse } from '../rpc-shared';
 import { RpcTransport } from '../rpc-transport';
 
 interface TestRpcMethods {
     someMethod(...args: unknown[]): unknown;
 }
 
-function createMockResponse<T>(jsonResponse: T): RpcResponse<T> {
-    return {
-        json: () => Promise.resolve(jsonResponse),
-        text: () => Promise.resolve(JSON.stringify(jsonResponse)),
-    };
-}
-
 describe('JSON-RPC 2.0', () => {
     let makeHttpRequest: RpcTransport;
     let rpc: Rpc<TestRpcMethods>;
@@ -41,7 +33,7 @@ describe('JSON-RPC 2.0', () => {
     });
     it('returns results from the transport', async () => {
         expect.assertions(1);
-        (makeHttpRequest as jest.Mock).mockResolvedValueOnce(createMockResponse(123));
+        (makeHttpRequest as jest.Mock).mockResolvedValueOnce(123);
         const result = await rpc.someMethod().send();
         expect(result).toBe(123);
     });
@@ -81,7 +73,7 @@ describe('JSON-RPC 2.0', () => {
         let responseTransformer: jest.Mock;
         let rpc: Rpc<TestRpcMethods>;
         beforeEach(() => {
-            responseTransformer = jest.fn(createJsonRpcResponseTransformer(json => `${json} processed response`));
+            responseTransformer = jest.fn(json => `${json} processed response`);
             rpc = createRpc({
                 api: {
                     someMethod(...params: unknown[]): RpcApiRequestPlan<unknown> {
@@ -97,14 +89,14 @@ describe('JSON-RPC 2.0', () => {
         });
         it('calls the response transformer with the response from the JSON-RPC 2.0 endpoint', async () => {
             expect.assertions(1);
-            const rawResponse = createMockResponse(123);
+            const rawResponse = 123;
             (makeHttpRequest as jest.Mock).mockResolvedValueOnce(rawResponse);
             await rpc.someMethod().send();
             expect(responseTransformer).toHaveBeenCalledWith(rawResponse, { methodName: 'someMethod', params: [] });
         });
         it('returns the processed response', async () => {
             expect.assertions(1);
-            (makeHttpRequest as jest.Mock).mockResolvedValueOnce(createMockResponse(123));
+            (makeHttpRequest as jest.Mock).mockResolvedValueOnce(123);
             const result = await rpc.someMethod().send();
             expect(result).toBe('123 processed response');
         });

packages/rpc-spec/src/rpc-shared.ts

@@ -3,10 +3,7 @@ export type RpcRequest<TParams = unknown> = {
     readonly params: TParams;
 };
 
-export type RpcResponse<TResponse = unknown> = {
-    readonly json: () => Promise<TResponse>;
-    readonly text: () => Promise<string>;
-};
+export type RpcResponse<TResponse = unknown> = TResponse;
 
 export type RpcRequestTransformer = {
     <TParams>(request: RpcRequest<TParams>): RpcRequest;
@@ -15,17 +12,3 @@ export type RpcRequestTransformer = {
 export type RpcResponseTransformer<TResponse = unknown> = {
     (response: RpcResponse, request: RpcRequest): RpcResponse<TResponse>;
 };
-
-export function createJsonRpcResponseTransformer<TResponse = unknown>(
-    jsonTransformer: (json: unknown, request: RpcRequest) => TResponse,
-): RpcResponseTransformer<TResponse> {
-    return function (response: RpcResponse, request: RpcRequest): RpcResponse<TResponse> {
-        return Object.freeze({
-            ...response,
-            json: async () => {
-                const json = await response.json();
-                return jsonTransformer(json, request);
-            },
-        });
-    };
-}

packages/rpc-spec/src/rpc.ts

@@ -79,8 +79,7 @@ function createPendingRpcRequest<TRpcMethods, TRpcTransport extends RpcTransport
                 payload: createRpcMessage(methodName, params),
                 signal: options?.abortSignal,
             });
-            const response = responseTransformer ? responseTransformer(rawResponse, request) : rawResponse;
-            return await response.json();
+            return responseTransformer ? responseTransformer(rawResponse, request) : rawResponse;
         },
     };
 }

packages/rpc-transformers/src/__tests__/response-transformer-test.ts

@@ -1,26 +1,17 @@
 import { SOLANA_ERROR__JSON_RPC__PARSE_ERROR, SolanaError } from '@solana/errors';
-import { RpcRequest, RpcResponse } from '@solana/rpc-spec';
+import { RpcRequest } from '@solana/rpc-spec';
 
 import { getDefaultResponseTransformerForSolanaRpc } from '../response-transformer';
 import { KEYPATH_WILDCARD } from '../tree-traversal';
 
-function createMockResponse<T>(jsonResponse: T): RpcResponse<T> {
-    return {
-        json: () => Promise.resolve(jsonResponse),
-        text: () => Promise.resolve(JSON.stringify(jsonResponse)),
-    };
-}
-
 describe('getDefaultResponseTransformerForSolanaRpc', () => {
     describe('given an array as input', () => {
         const input = [10, 10n, '10', ['10', [10n, 10], 10]] as const;
         const request = {} as RpcRequest;
-        const response = createMockResponse({ result: input });
-        it('casts the numbers in the array to a `bigint`, recursively', async () => {
-            expect.assertions(1);
+        const response = { result: input };
+        it('casts the numbers in the array to a `bigint`, recursively', () => {
             const transformer = getDefaultResponseTransformerForSolanaRpc();
-            const transformedResponse = transformer(response, request);
-            await expect(transformedResponse.json()).resolves.toStrictEqual([
+            expect(transformer(response, request)).toStrictEqual([
                 BigInt(input[0]),
                 input[1],
                 input[2],
@@ -31,13 +22,11 @@ describe('getDefaultResponseTransformerForSolanaRpc', () => {
     describe('given an object as input', () => {
         const input = { a: 10, b: 10n, c: { c1: '10', c2: 10 } } as const;
         const request = {} as RpcRequest;
-        const response = createMockResponse({ result: input });
+        const response = { result: input };
 
-        it('casts the numbers in the object to `bigints`, recursively', async () => {
-            expect.assertions(1);
+        it('casts the numbers in the object to `bigints`, recursively', () => {
             const transformer = getDefaultResponseTransformerForSolanaRpc();
-            const transformedResponse = transformer(response, request);
-            await expect(transformedResponse.json()).resolves.toStrictEqual({
+            expect(transformer(response, request)).toStrictEqual({
                 a: BigInt(input.a),
                 b: input.b,
                 c: { c1: input.c.c1, c2: BigInt(input.c.c2) },
@@ -54,29 +43,25 @@ describe('getDefaultResponseTransformerForSolanaRpc', () => {
             ${'numeric response'}                                | ${[[]]}                                              | ${10}                                                               | ${10}
         `(
             'performs no `bigint` upcasts on $description when the allowlist is of the form in test case $#',
-            async ({ allowedKeyPaths, expectation, input }) => {
-                expect.assertions(1);
+            ({ allowedKeyPaths, expectation, input }) => {
                 const transformer = getDefaultResponseTransformerForSolanaRpc({
                     allowedNumericKeyPaths: { getFoo: allowedKeyPaths },
                 });
                 const request = { methodName: 'getFoo' } as RpcRequest;
-                const response = createMockResponse({ result: input });
-                const transformedResponse = transformer(response, request);
-                await expect(transformedResponse.json()).resolves.toStrictEqual(expectation);
+                const response = { result: input };
+                expect(transformer(response, request)).toStrictEqual(expectation);
             },
         );
     });
     describe('given a JSON RPC error as input', () => {
         const request = {} as RpcRequest;
-        const response = createMockResponse({
+        const response = {
             error: { code: SOLANA_ERROR__JSON_RPC__PARSE_ERROR, message: 'o no' },
-        });
+        };
 
-        it('throws it as a SolanaError', async () => {
-            expect.assertions(1);
+        it('throws it as a SolanaError', () => {
             const transformer = getDefaultResponseTransformerForSolanaRpc();
-            const transformedResponse = transformer(response, request);
-            await expect(transformedResponse.json()).rejects.toThrow(
+            expect(() => transformer(response, request)).toThrow(
                 new SolanaError(SOLANA_ERROR__JSON_RPC__PARSE_ERROR, { __serverMessage: 'o no' }),
             );
         });

packages/rpc-transformers/src/response-transformer-result.ts

@@ -1,7 +1,7 @@
-import { createJsonRpcResponseTransformer } from '@solana/rpc-spec';
+import { RpcResponseTransformer } from '@solana/rpc-spec';
 
 type JsonRpcResponse = { result: unknown };
 
-export function getResultResponseTransformer() {
-    return createJsonRpcResponseTransformer(json => (json as JsonRpcResponse).result);
+export function getResultResponseTransformer(): RpcResponseTransformer {
+    return json => (json as JsonRpcResponse).result;
 }

packages/rpc-transformers/src/response-transformer-throw-solana-error.ts

@@ -1,14 +1,14 @@
 import { getSolanaErrorFromJsonRpcError } from '@solana/errors';
-import { createJsonRpcResponseTransformer } from '@solana/rpc-spec';
+import { RpcResponseTransformer } from '@solana/rpc-spec';
 
 type JsonRpcResponse = { error: Parameters<typeof getSolanaErrorFromJsonRpcError>[0] } | { result: unknown };
 
-export function getThrowSolanaErrorResponseTransformer() {
-    return createJsonRpcResponseTransformer(json => {
+export function getThrowSolanaErrorResponseTransformer(): RpcResponseTransformer {
+    return json => {
         const jsonRpcResponse = json as JsonRpcResponse;
         if ('error' in jsonRpcResponse) {
             throw getSolanaErrorFromJsonRpcError(jsonRpcResponse.error);
         }
         return jsonRpcResponse;
-    });
+    };
 }

packages/rpc-transformers/src/tree-traversal.ts

@@ -1,9 +1,4 @@
-import {
-    createJsonRpcResponseTransformer,
-    RpcRequest,
-    RpcRequestTransformer,
-    RpcResponseTransformer,
-} from '@solana/rpc-spec';
+import { RpcRequest, RpcRequestTransformer, RpcResponseTransformer } from '@solana/rpc-spec';
 
 export type KeyPathWildcard = { readonly __brand: unique symbol };
 export type KeyPath = ReadonlyArray<KeyPath | KeyPathWildcard | number | string>;
@@ -61,7 +56,5 @@ export function getTreeWalkerResponseTransformer<TState extends TraversalState>(
     visitors: NodeVisitor[],
     initialState: TState,
 ): RpcResponseTransformer {
-    return createJsonRpcResponseTransformer(json => {
-        return getTreeWalker(visitors)(json, initialState);
-    });
+    return json => getTreeWalker(visitors)(json, initialState);
 }

packages/rpc-transport-http/src/__tests__/http-transport-abort-test.ts

@@ -76,10 +76,7 @@ describe('createHttpTransport and `AbortSignal`', () => {
             } as unknown as Response);
             const sendPromise = makeHttpRequest({ payload: 123, signal: abortSignal });
             abortController.abort('I got bored waiting');
-            const response = await sendPromise;
-            await expect(response.json()).resolves.toMatchObject({
-                ok: true,
-            });
+            await expect(sendPromise).resolves.toMatchObject({ ok: true });
         });
     });
 });

packages/rpc-transport-http/src/http-transport.ts

@@ -66,9 +66,6 @@ export function createHttpTransport(config: Config): RpcTransport {
                 statusCode: response.status,
             });
         }
-        return Object.freeze({
-            json: () => response.json(),
-            text: () => response.text(),
-        });
+        return await response.json();
     };
 }