deps: Bump and align json-rpc packages

.eslintrc.js

@@ -8,6 +8,7 @@ module.exports = {
       files: ['*.ts'],
       extends: ['@metamask/eslint-config-typescript'],
       rules: {
+        '@typescript-eslint/prefer-nullish-coalescing': 'off',
         // TODO: resolve warnings and remove to make into errors
         '@typescript-eslint/consistent-type-definitions': 'off',
         '@typescript-eslint/naming-convention': 'off',

package.json

@@ -28,13 +28,13 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@metamask/eth-json-rpc-provider": "^1.0.0",
+    "@metamask/eth-json-rpc-provider": "^2.1.0",
     "@metamask/eth-sig-util": "^7.0.0",
+    "@metamask/json-rpc-engine": "^7.1.1",
+    "@metamask/rpc-errors": "^6.0.0",
     "@metamask/utils": "^8.1.0",
     "clone": "^2.1.1",
-    "eth-block-tracker": "^7.0.1",
-    "eth-rpc-errors": "^4.0.3",
-    "json-rpc-engine": "^6.1.0",
+    "eth-block-tracker": "^8.0.0",
     "pify": "^3.0.0",
     "safe-stable-stringify": "^2.3.2"
   },

src/block-cache.test.ts

@@ -1,6 +1,6 @@
 import { providerFromEngine } from '@metamask/eth-json-rpc-provider';
+import { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import { PollingBlockTracker } from 'eth-block-tracker';
-import { JsonRpcEngine } from 'json-rpc-engine';
 import pify from 'pify';
 
 import { createBlockCacheMiddleware } from '.';

src/block-cache.ts

@@ -1,6 +1,6 @@
+import { createAsyncMiddleware } from '@metamask/json-rpc-engine';
+import type { Json, JsonRpcParams, JsonRpcRequest } from '@metamask/utils';
 import type { PollingBlockTracker } from 'eth-block-tracker';
-import type { JsonRpcRequest } from 'json-rpc-engine';
-import { createAsyncMiddleware } from 'json-rpc-engine';
 
 import { projectLogger, createModuleLogger } from './logging-utils';
 import type {
@@ -32,7 +32,7 @@
 //
 
 class BlockCacheStrategy {
   private cache: Cache;
 
   constructor() {
     this.cache = {};
@@ -51,7 +51,7 @@
   }
 
   async get(
-    request: JsonRpcRequest<unknown>,
+    request: JsonRpcRequest,
     requestedBlockNumber: string,
   ): Promise<Block | undefined> {
     // lookup block cache
@@ -62,7 +62,7 @@
   }
 
   async set(
-    request: JsonRpcRequest<unknown>,
+    request: JsonRpcRequest,
     requestedBlockNumber: string,
     result: Block,
   ): Promise<void> {
@@ -81,7 +81,7 @@
     blockCache[identifier] = result;
   }
 
-  canCacheRequest(request: JsonRpcRequest<unknown>): boolean {
+  canCacheRequest(request: JsonRpcRequest): boolean {
     // check request method
     if (!canCache(request.method)) {
       return false;
@@ -96,7 +96,7 @@
     return true;
   }
 
-  canCacheResult(request: JsonRpcRequest<unknown>, result: Block): boolean {
+  canCacheResult(request: JsonRpcRequest, result: Block): boolean {
     // never cache empty values (e.g. undefined)
     if (emptyValues.includes(result as any)) {
       return false;
@@ -110,7 +110,7 @@
       )
     ) {
       if (
         !result ||
         !result.blockHash ||
         result.blockHash ===
           '0x0000000000000000000000000000000000000000000000000000000000000000'
@@ -135,7 +135,10 @@
 
 export function createBlockCacheMiddleware({
   blockTracker,
-}: BlockCacheMiddlewareOptions = {}): JsonRpcCacheMiddleware<unknown, unknown> {
+}: BlockCacheMiddlewareOptions = {}): JsonRpcCacheMiddleware<
+  JsonRpcParams,
+  Json
+> {
   // validate options
   if (!blockTracker) {
     throw new Error(
@@ -153,7 +156,7 @@
   };
 
   return createAsyncMiddleware(
-    async (req: JsonRpcRequestToCache<unknown>, res, next) => {
+    async (req: JsonRpcRequestToCache<JsonRpcParams>, res, next) => {
       // allow cach to be skipped if so specified
       if (req.skipCache) {
         return next();

src/block-ref-rewrite.ts

@@ -1,6 +1,7 @@
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
+import { createAsyncMiddleware } from '@metamask/json-rpc-engine';
+import type { Json, JsonRpcParams } from '@metamask/utils';
 import type { PollingBlockTracker } from 'eth-block-tracker';
-import type { JsonRpcMiddleware } from 'json-rpc-engine';
-import { createAsyncMiddleware } from 'json-rpc-engine';
 
 import { blockTagParamIndex } from './utils/cache';
 
@@ -10,7 +11,10 @@ interface BlockRefRewriteMiddlewareOptions {
 
 export function createBlockRefRewriteMiddleware({
   blockTracker,
-}: BlockRefRewriteMiddlewareOptions = {}): JsonRpcMiddleware<unknown, unknown> {
+}: BlockRefRewriteMiddlewareOptions = {}): JsonRpcMiddleware<
+  JsonRpcParams,
+  Json
+> {
   if (!blockTracker) {
     throw Error(
       'BlockRefRewriteMiddleware - mandatory "blockTracker" option is missing.',
@@ -24,13 +28,11 @@ export function createBlockRefRewriteMiddleware({
       return next();
     }
     // skip if not "latest"
-    let blockRef: string | undefined = Array.isArray(req.params)
-      ? req.params[blockRefIndex]
-      : undefined;
-    // omitted blockRef implies "latest"
-    if (blockRef === undefined) {
-      blockRef = 'latest';
-    }
+    const blockRef: string | undefined =
+      Array.isArray(req.params) && req.params[blockRefIndex]
+        ? (req.params[blockRefIndex] as string)
+        : // omitted blockRef implies "latest"
+          'latest';
 
     if (blockRef !== 'latest') {
       return next();

src/block-ref.test.ts

@@ -1,8 +1,8 @@
 import { providerFromEngine } from '@metamask/eth-json-rpc-provider';
 import type { SafeEventEmitterProvider } from '@metamask/eth-json-rpc-provider';
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
+import { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import { PollingBlockTracker } from 'eth-block-tracker';
-import type { JsonRpcMiddleware } from 'json-rpc-engine';
-import { JsonRpcEngine } from 'json-rpc-engine';
 
 import { createBlockRefMiddleware } from '.';
 import {

src/block-ref.ts

@@ -1,11 +1,13 @@
 import type { SafeEventEmitterProvider } from '@metamask/eth-json-rpc-provider';
-import clone from 'clone';
-import type { PollingBlockTracker } from 'eth-block-tracker';
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
+import { createAsyncMiddleware } from '@metamask/json-rpc-engine';
 import type {
-  JsonRpcMiddleware,
+  Json,
+  JsonRpcParams,
   PendingJsonRpcResponse,
-} from 'json-rpc-engine';
-import { createAsyncMiddleware } from 'json-rpc-engine';
+} from '@metamask/utils';
+import clone from 'clone';
+import type { PollingBlockTracker } from 'eth-block-tracker';
 import pify from 'pify';
 
 import { projectLogger, createModuleLogger } from './logging-utils';
@@ -22,7 +24,7 @@ const log = createModuleLogger(projectLogger, 'block-ref');
 export function createBlockRefMiddleware({
   provider,
   blockTracker,
-}: BlockRefMiddlewareOptions = {}): JsonRpcMiddleware<unknown, unknown> {
+}: BlockRefMiddlewareOptions = {}): JsonRpcMiddleware<JsonRpcParams, Json> {
   if (!provider) {
     throw Error('BlockRefMiddleware - mandatory "provider" option is missing.');
   }

src/block-tracker-inspector.ts

@@ -1,9 +1,11 @@
-import type { PollingBlockTracker } from 'eth-block-tracker';
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
+import { createAsyncMiddleware } from '@metamask/json-rpc-engine';
 import type {
-  JsonRpcMiddleware,
+  Json,
+  JsonRpcParams,
   PendingJsonRpcResponse,
-} from 'json-rpc-engine';
-import { createAsyncMiddleware } from 'json-rpc-engine';
+} from '@metamask/utils';
+import type { PollingBlockTracker } from 'eth-block-tracker';
 
 import { projectLogger, createModuleLogger } from './logging-utils';
 
@@ -37,7 +39,7 @@ function hasProperty<ObjectToCheck, Property extends ValidPropertyType>(
 }
 
 function getResultBlockNumber(
-  response: PendingJsonRpcResponse<unknown>,
+  response: PendingJsonRpcResponse<Json>,
 ): string | undefined {
   const { result } = response;
   if (
@@ -58,8 +60,8 @@ function getResultBlockNumber(
 export function createBlockTrackerInspectorMiddleware({
   blockTracker,
 }: BlockTrackerInspectorMiddlewareOptions): JsonRpcMiddleware<
-  unknown,
-  unknown
+  JsonRpcParams,
+  Json
 > {
   return createAsyncMiddleware(async (req, res, next) => {
     if (!futureBlockRefRequests.includes(req.method)) {

src/fetch.ts

@@ -1,7 +1,8 @@
-import type { EthereumRpcError } from 'eth-rpc-errors';
-import { ethErrors } from 'eth-rpc-errors';
-import type { JsonRpcMiddleware, JsonRpcRequest } from 'json-rpc-engine';
-import { createAsyncMiddleware } from 'json-rpc-engine';
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
+import { createAsyncMiddleware } from '@metamask/json-rpc-engine';
+import type { JsonRpcError, DataWithOptionalCause } from '@metamask/rpc-errors';
+import { rpcErrors } from '@metamask/rpc-errors';
+import type { Json, JsonRpcParams, JsonRpcRequest } from '@metamask/utils';
 
 import type { Block } from './types';
 import { timeout } from './utils/timeout';
@@ -17,7 +18,7 @@
   'Failed to fetch',
 ];
 
-export interface PayloadWithOrigin extends JsonRpcRequest<unknown> {
+export interface PayloadWithOrigin extends JsonRpcRequest {
   origin?: string;
 }
 interface Request {
@@ -33,7 +34,7 @@
 /**
  * Create middleware for sending a JSON-RPC request to the given RPC URL.
  *
  * @param options - Options
  * @param options.btoa - Generates a base64-encoded string from a binary string.
  * @param options.fetch - The `fetch` function; expected to be equivalent to `window.fetch`.
  * @param options.rpcUrl - The URL to send the request to.
@@ -53,7 +54,7 @@
   fetch: typeof global.fetch;
   rpcUrl: string;
   originHttpHeaderKey?: string;
-}): JsonRpcMiddleware<unknown, unknown> {
+}): JsonRpcMiddleware<JsonRpcParams, Json> {
   return createAsyncMiddleware(async (req, res, _next) => {
     const { fetchUrl, fetchParams } = createFetchConfigFromReq({
       btoa,
@@ -104,7 +105,7 @@
   // check for errors
   switch (fetchRes.status) {
     case 405:
-      throw ethErrors.rpc.methodNotFound();
+      throw rpcErrors.methodNotFound();
 
     case 418:
       throw createRatelimitError();
@@ -121,15 +122,15 @@
 function parseResponse(fetchRes: Response, body: Record<string, Block>): Block {
   // check for error code
   if (fetchRes.status !== 200) {
-    throw ethErrors.rpc.internal({
+    throw rpcErrors.internal({
       message: `Non-200 status code: '${fetchRes.status}'`,
       data: body,
     });
   }
 
   // check for rpc error
   if (body.error) {
-    throw ethErrors.rpc.internal({
+    throw rpcErrors.internal({
       data: body.error,
     });
   }
@@ -140,12 +141,12 @@
 /**
  * Generate `fetch` configuration for sending the given request to an RPC API.
  *
  * @param options - Options
  * @param options.btoa - Generates a base64-encoded string from a binary string.
  * @param options.rpcUrl - The URL to send the request to.
  * @param options.originHttpHeaderKey - If provider, the origin field for each JSON-RPC request
  * will be attached to each outgoing fetch request under this header.
  * @param options.req
  * @returns The fetch middleware.
  */
 export function createFetchConfigFromReq({
@@ -165,7 +166,7 @@
 
   // prepare payload
   // copy only canonical json rpc properties
-  const payload: JsonRpcRequest<unknown> = {
+  const payload: JsonRpcRequest = {
     id: req.id,
     jsonrpc: req.jsonrpc,
     method: req.method,
@@ -215,12 +216,12 @@
   return result;
 }
 
-function createRatelimitError(): EthereumRpcError<unknown> {
-  return ethErrors.rpc.internal({ message: `Request is being rate limited.` });
+function createRatelimitError(): JsonRpcError<DataWithOptionalCause> {
+  return rpcErrors.internal({ message: `Request is being rate limited.` });
 }
 
-function createTimeoutError(): EthereumRpcError<unknown> {
+function createTimeoutError(): JsonRpcError<DataWithOptionalCause> {
   let msg = `Gateway timeout. The request took too long to process. `;
   msg += `This can happen when querying logs over too wide a block range.`;
-  return ethErrors.rpc.internal({ message: msg });
+  return rpcErrors.internal({ message: msg });
 }

src/inflight-cache.test.ts

@@ -1,4 +1,4 @@
-import { JsonRpcEngine } from 'json-rpc-engine';
+import { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import pify from 'pify';
 
 import { createInflightCacheMiddleware } from '.';

src/inflight-cache.ts

@@ -1,26 +1,30 @@
+import { createAsyncMiddleware } from '@metamask/json-rpc-engine';
+import type {
+  JsonRpcParams,
+  Json,
+  PendingJsonRpcResponse,
+} from '@metamask/utils';
 import clone from 'clone';
-import type { PendingJsonRpcResponse } from 'json-rpc-engine';
-import { createAsyncMiddleware } from 'json-rpc-engine';
 
 import { projectLogger, createModuleLogger } from './logging-utils';
 import type { JsonRpcRequestToCache, JsonRpcCacheMiddleware } from './types';
 import { cacheIdentifierForRequest } from './utils/cache';
 
-type RequestHandlers = (handledRes: PendingJsonRpcResponse<unknown>) => void;
+type RequestHandlers = (handledRes: PendingJsonRpcResponse<Json>) => void;
 interface InflightRequest {
   [cacheId: string]: RequestHandlers[];
 }
 
 const log = createModuleLogger(projectLogger, 'inflight-cache');
 
 export function createInflightCacheMiddleware(): JsonRpcCacheMiddleware<
-  unknown,
-  unknown
+  JsonRpcParams,
+  Json
 > {
   const inflightRequests: InflightRequest = {};
 
   return createAsyncMiddleware(
-    async (req: JsonRpcRequestToCache<unknown>, res, next) => {
+    async (req: JsonRpcRequestToCache<JsonRpcParams>, res, next) => {
       // allow cach to be skipped if so specified
       if (req.skipCache) {
         return next();
@@ -68,23 +72,21 @@ export function createInflightCacheMiddleware(): JsonRpcCacheMiddleware<
   );
 
   async function createActiveRequestHandler(
-    res: PendingJsonRpcResponse<unknown>,
+    res: PendingJsonRpcResponse<Json>,
     activeRequestHandlers: RequestHandlers[],
   ): Promise<void> {
     const { resolve, promise } = deferredPromise();
-    activeRequestHandlers.push(
-      (handledRes: PendingJsonRpcResponse<unknown>) => {
-        // append a copy of the result and error to the response
-        res.result = clone(handledRes.result);
-        res.error = clone(handledRes.error);
-        resolve();
-      },
-    );
+    activeRequestHandlers.push((handledRes: PendingJsonRpcResponse<Json>) => {
+      // append a copy of the result and error to the response
+      res.result = clone(handledRes.result);
+      res.error = clone(handledRes.error);
+      resolve();
+    });
     return promise;
   }
 
   function handleActiveRequest(
-    res: PendingJsonRpcResponse<unknown>,
+    res: PendingJsonRpcResponse<Json>,
     activeRequestHandlers: RequestHandlers[],
   ): void {
     // use setTimeout so we can resolve our original request first