Quicknode provider update (#7195)

jdevcs · web-flow · commit d9d0391003f2 · 2024-08-20T10:13:14.000+02:00
* added response status code in response error

* statusCode in ResponseError

* updated error message and it will throw on status code 429

* updated error test snapshot

* updated test

* updated test for QN

* Quicknode provider error

* Web3ExternalProvider update

* mock ws

* lint fix
diff --git a/packages/web3-errors/CHANGELOG.md b/packages/web3-errors/CHANGELOG.md
@@ -178,4 +178,8 @@ Documentation:
 
 - Fixed the undefined data in `Eip838ExecutionError` constructor (#6905)
 
-## [Unreleased]
+## [Unreleased]
+
+### Added
+
+- Added optional `statusCode` property of response in ResponseError.
diff --git a/packages/web3-errors/src/errors/response_errors.ts b/packages/web3-errors/src/errors/response_errors.ts
@@ -45,11 +45,13 @@ export class ResponseError<ErrorType = unknown, RequestType = unknown> extends B
 	public code = ERR_RESPONSE;
 	public data?: ErrorType | ErrorType[];
 	public request?: JsonRpcPayload<RequestType>;
+	public statusCode?: number;
 
 	public constructor(
 		response: JsonRpcResponse<unknown, ErrorType>,
 		message?: string,
 		request?: JsonRpcPayload<RequestType>,
+		statusCode?: number
 	) {
 		super(
 			message ??
@@ -66,6 +68,7 @@ export class ResponseError<ErrorType = unknown, RequestType = unknown> extends B
 				: response?.error?.data;
 		}
 
+		this.statusCode = statusCode;
 		this.request = request;
 		let errorOrErrors: JsonRpcError | JsonRpcError[] | undefined;
 		if (`error` in response) {
@@ -82,7 +85,7 @@ export class ResponseError<ErrorType = unknown, RequestType = unknown> extends B
 	}
 
 	public toJSON() {
-		return { ...super.toJSON(), data: this.data, request: this.request };
+		return { ...super.toJSON(), data: this.data, request: this.request, statusCode: this.statusCode };
 	}
 }
 
diff --git a/packages/web3-errors/test/unit/__snapshots__/errors.test.ts.snap b/packages/web3-errors/test/unit/__snapshots__/errors.test.ts.snap
@@ -239,6 +239,7 @@ exports[`errors InvalidResponseError should have valid json structure 1`] = `
   "message": "Returned error: error message",
   "name": "InvalidResponseError",
   "request": undefined,
+  "statusCode": undefined,
 }
 `;
 
@@ -316,6 +317,7 @@ exports[`errors ResponseError should have valid json structure with data 1`] = `
   "message": "Returned error: error message",
   "name": "ResponseError",
   "request": undefined,
+  "statusCode": undefined,
 }
 `;
 
@@ -336,6 +338,7 @@ exports[`errors ResponseError should have valid json structure without data 1`]
   "message": "Returned error: error message",
   "name": "ResponseError",
   "request": undefined,
+  "statusCode": undefined,
 }
 `;
 
@@ -357,6 +360,7 @@ exports[`errors ResponseError should include the array of inner errors 1`] = `
   "message": "Returned error: error message,error message",
   "name": "ResponseError",
   "request": undefined,
+  "statusCode": undefined,
 }
 `;
 
diff --git a/packages/web3-providers-http/CHANGELOG.md b/packages/web3-providers-http/CHANGELOG.md
@@ -129,4 +129,8 @@ Documentation:
 
 -   Fix issue lquixada/cross-fetch#78, enabling to run web3.js in service worker (#6463)
 
-## [Unreleased]
+## [Unreleased]
+
+### Added
+
+- Added `statusCode` of response in ResponseError, `statusCode` is optional property in ResponseError.
diff --git a/packages/web3-providers-http/src/index.ts b/packages/web3-providers-http/src/index.ts
@@ -80,7 +80,7 @@ export default class HttpProvider<
 		});
 		if (!response.ok) { 
 			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-			throw new ResponseError(await response.json())
+			throw new ResponseError(await response.json(), undefined, undefined, response.status);
 		};
 
 		return (await response.json()) as JsonRpcResponseWithResult<ResultType>;
diff --git a/packages/web3-rpc-providers/CHANGELOG.md b/packages/web3-rpc-providers/CHANGELOG.md
@@ -43,12 +43,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [1.0.0.rc.1]
 
- ### Added
+### Added
 
  - When error is returned with code 429, throw rate limit error (#7102)
 
- ### Changed
+### Changed
 
  - Change request return type `Promise<ResultType>` to `Promise<JsonRpcResponseWithResult<ResultType>>` (#7102)
 
-## [Unreleased]
+## [Unreleased]
+
+### Added
+
+-   Updated rate limit error of QuickNode provider for HTTP transport
diff --git a/packages/web3-rpc-providers/package.json b/packages/web3-rpc-providers/package.json
@@ -49,6 +49,7 @@
 		"eslint-config-base-web3": "0.1.0",
 		"eslint-config-prettier": "^8.5.0",
 		"eslint-plugin-import": "^2.26.0",
+		"isomorphic-ws": "^5.0.0",
 		"jest": "^29.7.0",
 		"jest-extended": "^3.0.1",
 		"prettier": "^2.7.1",
diff --git a/packages/web3-rpc-providers/src/errors.ts b/packages/web3-rpc-providers/src/errors.ts
@@ -16,13 +16,12 @@ along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { BaseWeb3Error } from 'web3-errors';
-import {  } from 'web3-types';
 
 const ERR_QUICK_NODE_RATE_LIMIT = 1300;
 export class QuickNodeRateLimitError extends BaseWeb3Error {
 	public code = ERR_QUICK_NODE_RATE_LIMIT;
 
-	public constructor() {
-		super(`Too many requests, Quicknode has reached its rate limit.`);
+	public constructor(error?: Error) {
+		super(`You've reach the rate limit of free RPC calls from our Partner Quick Nodes. There are two options you can either create a paid Quick Nodes account and get 20% off for 2 months using WEB3JS referral code, or use Free public RPC endpoint.`, error);
 	}
 }
diff --git a/packages/web3-rpc-providers/src/index.ts b/packages/web3-rpc-providers/src/index.ts
@@ -20,6 +20,7 @@ import { QuickNodeProvider } from './web3_provider_quicknode.js';
 export * from './types.js';
 export * from './web3_provider_quicknode.js';
 export * from './web3_provider.js';
+export * from './errors.js';
 
 // default providers
 export const mainnet = new QuickNodeProvider(); 
diff --git a/packages/web3-rpc-providers/src/web3_provider.ts b/packages/web3-rpc-providers/src/web3_provider.ts
@@ -17,7 +17,6 @@ along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 
 import HttpProvider from "web3-providers-http";
 import WebSocketProvider from "web3-providers-ws";
-import { isNullish } from "web3-validator";
 import {
     EthExecutionAPI, JsonRpcResult, ProviderConnectInfo, ProviderMessage,
     ProviderRpcError, Web3APIMethod, Web3APIPayload, Web3APIReturnType, Web3APISpec, Web3BaseProvider,
@@ -29,7 +28,6 @@ import {
 } from "web3-types";
 import { Eip1193Provider } from "web3-utils";
 import { Transport, Network } from "./types.js";
-import { QuickNodeRateLimitError } from './errors.js';
 
 /* 
 This class can be used to create new providers only when there is custom logic required in each Request method like
@@ -39,21 +37,21 @@ Another simpler approach can be a function simply returning URL strings instead
 no additional logic implementation is required in the provider.
 */
 
-export abstract class Web3ExternalProvider <
-API extends Web3APISpec = EthExecutionAPI,
+export abstract class Web3ExternalProvider<
+    API extends Web3APISpec = EthExecutionAPI,
 > extends Eip1193Provider {
 
     public provider!: Web3BaseProvider;
     public readonly transport: Transport;
 
-    public abstract getRPCURL(network: Network,transport: Transport,token: string, host: string): string;
+    public abstract getRPCURL(network: Network, transport: Transport, token: string, host: string): string;
 
     public constructor(
         network: Network,
         transport: Transport,
         token: string,
         host: string) {
-            
+
         super();
 
         this.transport = transport;
@@ -74,18 +72,11 @@ API extends Web3APISpec = EthExecutionAPI,
     ): Promise<JsonRpcResponseWithResult<ResultType>> {
 
         if (this.transport === Transport.HTTPS) {
-                const res = await ( (this.provider as HttpProvider).request(payload, requestOptions)) as unknown as JsonRpcResponseWithResult<ResultType>;
-                
-                if (typeof res === 'object' && !isNullish(res) && 'error' in res && !isNullish(res.error) && 'code' in res.error && (res.error as { code: number }).code === 429){
-                    // rate limiting error by quicknode;
-                    throw new QuickNodeRateLimitError();
-                    
-                }
-                return res;
-            }
-        
+            return await ((this.provider as HttpProvider).request(payload, requestOptions)) as unknown as JsonRpcResponseWithResult<ResultType>;
+        }
+
         return (this.provider as WebSocketProvider).request(payload);
-        
+
     }
 
     public getStatus(): Web3ProviderStatus {
diff --git a/packages/web3-rpc-providers/src/web3_provider_quicknode.ts b/packages/web3-rpc-providers/src/web3_provider_quicknode.ts
@@ -15,12 +15,17 @@ You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+import { EthExecutionAPI, JsonRpcResponseWithResult, Web3APIMethod, Web3APIPayload, Web3APIReturnType, Web3APISpec } from "web3-types";
+import { ResponseError } from "web3-errors";
 import { Transport, Network } from "./types.js";
 import { Web3ExternalProvider } from "./web3_provider.js";
+import { QuickNodeRateLimitError } from "./errors.js";
 
 const isValid = (str: string) => str !== undefined && str.trim().length > 0;
 
-export class QuickNodeProvider extends Web3ExternalProvider {
+export class QuickNodeProvider<
+API extends Web3APISpec = EthExecutionAPI,
+> extends Web3ExternalProvider {
 
     public constructor(
         network: Network = Network.ETH_MAINNET,
@@ -32,6 +37,24 @@ export class QuickNodeProvider extends Web3ExternalProvider {
 
     }
 
+    public async request<
+        Method extends Web3APIMethod<API>,
+        ResultType = Web3APIReturnType<API, Method>,
+    >(
+        payload: Web3APIPayload<EthExecutionAPI, Method>,
+        requestOptions?: RequestInit,
+    ): Promise<JsonRpcResponseWithResult<ResultType>> {
+
+        try {
+            return await super.request(payload, requestOptions);
+        } catch (error) {
+            if (error instanceof ResponseError && error.statusCode === 429){
+                throw new QuickNodeRateLimitError(error);
+            }
+            throw error;
+        }
+    }
+
     // eslint-disable-next-line class-methods-use-this
     public getRPCURL(network: Network,
         transport: Transport,
diff --git a/packages/web3-rpc-providers/test/unit/constructor.test.ts b/packages/web3-rpc-providers/test/unit/constructor.test.ts
@@ -14,13 +14,51 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
-/* eslint-disable max-classes-per-file */
+
 
 import HttpProvider from 'web3-providers-http';
 import WebSocketProvider from 'web3-providers-ws';
+import WebSocket from 'isomorphic-ws';
+
 import { Web3ExternalProvider } from '../../src/web3_provider';
 import { Network, Transport } from '../../src/types';
 
+// Mock implementation so ws doesnt have openhandle after test exits as it attempts to connects at start
+jest.mock('isomorphic-ws', () => {
+  return {
+    __esModule: true,
+    default: jest.fn().mockImplementation(() => {
+      // eslint-disable-next-line @typescript-eslint/ban-types 
+      const eventListeners: { [key: string]: Function[] } = {};
+
+      return {
+        addEventListener: jest.fn((event, handler) => {
+          if (!eventListeners[event]) {
+            eventListeners[event] = [];
+          }
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          eventListeners[event].push(handler);
+        }),
+        removeEventListener: jest.fn((event, handler) => {
+          if (eventListeners[event]) {
+            eventListeners[event] = eventListeners[event].filter(h => h !== handler);
+          }
+        }),
+        dispatchEvent: jest.fn((event) => {
+          const eventType = event.type;
+          if (eventListeners[eventType]) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            eventListeners[eventType].forEach(handler => handler(event));
+          }
+        }),
+        close: jest.fn(),
+        send: jest.fn(),
+        readyState: WebSocket.OPEN,
+      };
+    }),
+  };
+});
+
 class MockWeb3ExternalProviderA extends Web3ExternalProvider {
   public constructor(network: Network, transport: Transport, token: string){
     super(network, transport, token, "");
@@ -33,7 +71,7 @@ class MockWeb3ExternalProviderA extends Web3ExternalProvider {
     else if (_transport === Transport.WebSocket)
       transport = "wss://";
 
-    return `${transport}example.com/`;
+    return `${transport}127.0.0.1/`;
   }
 }
 
@@ -54,9 +92,7 @@ describe('Web3ExternalProvider', () => {
     const token = 'your-token';
 
     const provider = new MockWeb3ExternalProviderA(network, transport, token);
-
     expect(provider.provider).toBeInstanceOf(WebSocketProvider);
   });
 
 });
-/* eslint-enable max-classes-per-file */
diff --git a/packages/web3-rpc-providers/test/unit/request.test.ts b/packages/web3-rpc-providers/test/unit/request.test.ts
@@ -14,10 +14,12 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
-import { Web3APIPayload, EthExecutionAPI, Web3APIMethod } from "web3-types";
+import { Web3APIPayload, EthExecutionAPI, Web3APIMethod, JsonRpcResponse } from "web3-types";
+import { ResponseError } from "web3-errors";
 import { Network, Transport } from "../../src/types";
 import { Web3ExternalProvider } from "../../src/web3_provider";
 import { QuickNodeRateLimitError } from '../../src/errors';
+import { QuickNodeProvider } from '../../src/web3_provider_quicknode';
 
 jest.mock('web3-providers-ws', () => {
   return {
@@ -79,7 +81,8 @@ describe('Web3ExternalProvider', () => {
     const result = await provider.request(payload);
     expect(result).toEqual({ result: 'mock-result' });
   });
-  it('should return a rate limiting error when code is 429', async () => {
+
+  it('should throw a rate limiting error when status code is 429', async () => {
     const network: Network = Network.ETH_MAINNET;
     const transport: Transport = Transport.HTTPS;
     const token = 'your-token';
@@ -88,17 +91,29 @@ describe('Web3ExternalProvider', () => {
       request: jest.fn(),
     };
 
-    const mockResponse = {
+    // Create a mock ResponseError with status code 429
+    // Create a mock JsonRpcResponse to pass to ResponseError
+    const mockJsonRpcResponse: JsonRpcResponse = {
       jsonrpc: '2.0',
       id: '458408f4-7e2c-43f1-b61d-1fe09a9ee25a',
       error: {
         code: 429,
-        message: 'the method eth_stuff does not exist/is not available'
-      }
+        message: 'Rate limit exceeded',
+      },
     };
-    mockHttpProvider.request.mockResolvedValue(mockResponse);
 
-    const provider = new MockWeb3ExternalProvider(network, transport, token);
+    // Create a mock ResponseError with status code 429
+    const mockError = new ResponseError(
+      mockJsonRpcResponse,
+      undefined,
+      undefined, // request can be undefined
+      429 // statusCode
+    );
+
+    // Mock the request method to throw the ResponseError
+    mockHttpProvider.request.mockRejectedValue(mockError);
+
+    const provider = new QuickNodeProvider(network, transport, token);
     (provider as any).provider = mockHttpProvider; 
 
     const payload: Web3APIPayload<EthExecutionAPI, Web3APIMethod<EthExecutionAPI>> = {
@@ -107,4 +122,5 @@ describe('Web3ExternalProvider', () => {
     };
     await expect(provider.request(payload)).rejects.toThrow(QuickNodeRateLimitError);
   });
+
 });

Original file line number	Diff line number	Diff line change
`@@ -16,13 +16,12 @@ along with web3.js. If not, see <http://www.gnu.org/licenses/>.`
`16`	`16`	`*/`
`17`	`17`
`18`	`18`	`import { BaseWeb3Error } from 'web3-errors';`
`19`		`-import { } from 'web3-types';`
`20`	`19`
`21`	`20`	`const ERR_QUICK_NODE_RATE_LIMIT = 1300;`
`22`	`21`	`export class QuickNodeRateLimitError extends BaseWeb3Error {`
`23`	`22`	`public code = ERR_QUICK_NODE_RATE_LIMIT;`
`24`	`23`
`25`		`- public constructor() {`
`26`		- super(`Too many requests, Quicknode has reached its rate limit.`);
	`24`	`+ public constructor(error?: Error) {`
	`25`	+ super(`You've reach the rate limit of free RPC calls from our Partner Quick Nodes. There are two options you can either create a paid Quick Nodes account and get 20% off for 2 months using WEB3JS referral code, or use Free public RPC endpoint.`, error);
`27`	`26`	`}`
`28`	`27`	`}`