@metamask-previews/network-controller 36.0.0-preview-4f4c98e → 36.0.0-preview-5b293ee50

package/dist/rpc-service/rpc-service-requestable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-service-requestable.cjs","sourceRoot":"","sources":["../../src/rpc-service/rpc-service-requestable.ts"],"names":[],"mappings":"","sourcesContent":["import type { ServicePolicy } from '@metamask/controller-utils';\nimport type {\n  Json,\n  JsonRpcParams,\n  JsonRpcRequest,\n  JsonRpcResponse,\n} from '@metamask/utils';\n\nimport type {\n  CockatielEventToEventListenerWithData,\n  ExcludeCockatielEventData,\n  ExtendCockatielEventData,\n  ExtractCockatielEventData,\n  FetchOptions,\n} from './shared.js';\n\n/**\n * The interface for a service class responsible for making a request to a\n * target, whether that is a single RPC endpoint or an RPC endpoint in an RPC\n * service chain.\n *\n * @deprecated Don't use this interface (it will be removed in an upcoming major\n * version). If you need to take an \"RPC-service-like\" argument, it's best to\n * declare which properties you're interested in rather than accepting the\n * entire RPC service interface.\n */\nexport type RpcServiceRequestable = {\n  /**\n   * Listens for when the RPC service retries the request.\n   *\n   * @param listener - The callback to be called when the retry occurs.\n   * @returns What {@link ServicePolicy.onRetry} returns.\n   * @see {@link createServicePolicy}\n   */\n  onRetry(\n    listener: CockatielEventToEventListenerWithData<\n      ServicePolicy['onRetry'],\n      { endpointUrl: string }\n    >,\n  ): ReturnType<ServicePolicy['onRetry']>;\n\n  /**\n   * Listens for when the RPC service retries the request too many times in a\n   * row.\n   *\n   * @param listener - The callback to be called when the circuit is broken.\n   * @returns What {@link ServicePolicy.onBreak} returns.\n   * @see {@link createServicePolicy}\n   */\n  onBreak(\n    listener: (\n      data: ExcludeCockatielEventData<\n        ExtendCockatielEventData<\n          ExtractCockatielEventData<ServicePolicy['onBreak']>,\n          { endpointUrl: string }\n        >,\n        'isolated'\n      >,\n    ) => void,\n  ): ReturnType<ServicePolicy['onBreak']>;\n\n  /**\n   * Listens for when the policy underlying this RPC service detects a slow\n   * request.\n   *\n   * @param listener - The callback to be called when the request is slow.\n   * @returns What {@link ServicePolicy.onDegraded} returns.\n   * @see {@link createServicePolicy}\n   */\n  onDegraded(\n    listener: CockatielEventToEventListenerWithData<\n      ServicePolicy['onDegraded'],\n      { endpointUrl: string; rpcMethodName: string }\n    >,\n  ): ReturnType<ServicePolicy['onDegraded']>;\n\n  /**\n   * Listens for when the policy underlying this RPC service is available.\n   *\n   * @param listener - The callback to be called when the request is available.\n   * @returns What {@link ServicePolicy.onDegraded} returns.\n   * @see {@link createServicePolicy}\n   */\n  onAvailable(\n    listener: CockatielEventToEventListenerWithData<\n      ServicePolicy['onAvailable'],\n      { endpointUrl: string }\n    >,\n  ): ReturnType<ServicePolicy['onAvailable']>;\n\n  /**\n   * Makes a request to the target.\n   */\n  request<Params extends JsonRpcParams, Result extends Json>(\n    jsonRpcRequest: Readonly<JsonRpcRequest<Params>>,\n    fetchOptions?: FetchOptions,\n  ): Promise<JsonRpcResponse<Result | null>>;\n};\n"]}

package/dist/rpc-service/{rpc-service-requestable.d.ts → rpc-service-requestable.d.cts}

@@ -1,6 +1,6 @@
-import type { ServicePolicy } from '@metamask/controller-utils';
-import type { Json, JsonRpcParams, JsonRpcRequest, JsonRpcResponse } from '@metamask/utils';
-import type { CockatielEventToEventListenerWithData, ExcludeCockatielEventData, ExtendCockatielEventData, ExtractCockatielEventData, FetchOptions } from './shared.js';
+import type { ServicePolicy } from "@metamask/controller-utils";
+import type { Json, JsonRpcParams, JsonRpcRequest, JsonRpcResponse } from "@metamask/utils";
+import type { CockatielEventToEventListenerWithData, ExcludeCockatielEventData, ExtendCockatielEventData, ExtractCockatielEventData, FetchOptions } from "./shared.cjs";
 /**
  * The interface for a service class responsible for making a request to a
  * target, whether that is a single RPC endpoint or an RPC endpoint in an RPC
@@ -60,4 +60,4 @@ export type RpcServiceRequestable = {
      */
     request<Params extends JsonRpcParams, Result extends Json>(jsonRpcRequest: Readonly<JsonRpcRequest<Params>>, fetchOptions?: FetchOptions): Promise<JsonRpcResponse<Result | null>>;
 };
-//# sourceMappingURL=rpc-service-requestable.d.ts.map
+//# sourceMappingURL=rpc-service-requestable.d.cts.map

package/dist/rpc-service/rpc-service-requestable.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-service-requestable.d.cts","sourceRoot":"","sources":["../../src/rpc-service/rpc-service-requestable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,mCAAmC;AAChE,OAAO,KAAK,EACV,IAAI,EACJ,aAAa,EACb,cAAc,EACd,eAAe,EAChB,wBAAwB;AAEzB,OAAO,KAAK,EACV,qCAAqC,EACrC,yBAAyB,EACzB,wBAAwB,EACxB,yBAAyB,EACzB,YAAY,EACb,qBAAoB;AAErB;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;;;OAMG;IACH,OAAO,CACL,QAAQ,EAAE,qCAAqC,CAC7C,aAAa,CAAC,SAAS,CAAC,EACxB;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CACxB,GACA,UAAU,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC;IAExC;;;;;;;OAOG;IACH,OAAO,CACL,QAAQ,EAAE,CACR,IAAI,EAAE,yBAAyB,CAC7B,wBAAwB,CACtB,yBAAyB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,EACnD;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CACxB,EACD,UAAU,CACX,KACE,IAAI,GACR,UAAU,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC;IAExC;;;;;;;OAOG;IACH,UAAU,CACR,QAAQ,EAAE,qCAAqC,CAC7C,aAAa,CAAC,YAAY,CAAC,EAC3B;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAC/C,GACA,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC;IAE3C;;;;;;OAMG;IACH,WAAW,CACT,QAAQ,EAAE,qCAAqC,CAC7C,aAAa,CAAC,aAAa,CAAC,EAC5B;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CACxB,GACA,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;IAE5C;;OAEG;IACH,OAAO,CAAC,MAAM,SAAS,aAAa,EAAE,MAAM,SAAS,IAAI,EACvD,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EAChD,YAAY,CAAC,EAAE,YAAY,GAC1B,OAAO,CAAC,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;CAC5C,CAAC"}

package/dist/rpc-service/rpc-service-requestable.d.mts

@@ -0,0 +1,63 @@
+import type { ServicePolicy } from "@metamask/controller-utils";
+import type { Json, JsonRpcParams, JsonRpcRequest, JsonRpcResponse } from "@metamask/utils";
+import type { CockatielEventToEventListenerWithData, ExcludeCockatielEventData, ExtendCockatielEventData, ExtractCockatielEventData, FetchOptions } from "./shared.mjs";
+/**
+ * The interface for a service class responsible for making a request to a
+ * target, whether that is a single RPC endpoint or an RPC endpoint in an RPC
+ * service chain.
+ *
+ * @deprecated Don't use this interface (it will be removed in an upcoming major
+ * version). If you need to take an "RPC-service-like" argument, it's best to
+ * declare which properties you're interested in rather than accepting the
+ * entire RPC service interface.
+ */
+export type RpcServiceRequestable = {
+    /**
+     * Listens for when the RPC service retries the request.
+     *
+     * @param listener - The callback to be called when the retry occurs.
+     * @returns What {@link ServicePolicy.onRetry} returns.
+     * @see {@link createServicePolicy}
+     */
+    onRetry(listener: CockatielEventToEventListenerWithData<ServicePolicy['onRetry'], {
+        endpointUrl: string;
+    }>): ReturnType<ServicePolicy['onRetry']>;
+    /**
+     * Listens for when the RPC service retries the request too many times in a
+     * row.
+     *
+     * @param listener - The callback to be called when the circuit is broken.
+     * @returns What {@link ServicePolicy.onBreak} returns.
+     * @see {@link createServicePolicy}
+     */
+    onBreak(listener: (data: ExcludeCockatielEventData<ExtendCockatielEventData<ExtractCockatielEventData<ServicePolicy['onBreak']>, {
+        endpointUrl: string;
+    }>, 'isolated'>) => void): ReturnType<ServicePolicy['onBreak']>;
+    /**
+     * Listens for when the policy underlying this RPC service detects a slow
+     * request.
+     *
+     * @param listener - The callback to be called when the request is slow.
+     * @returns What {@link ServicePolicy.onDegraded} returns.
+     * @see {@link createServicePolicy}
+     */
+    onDegraded(listener: CockatielEventToEventListenerWithData<ServicePolicy['onDegraded'], {
+        endpointUrl: string;
+        rpcMethodName: string;
+    }>): ReturnType<ServicePolicy['onDegraded']>;
+    /**
+     * Listens for when the policy underlying this RPC service is available.
+     *
+     * @param listener - The callback to be called when the request is available.
+     * @returns What {@link ServicePolicy.onDegraded} returns.
+     * @see {@link createServicePolicy}
+     */
+    onAvailable(listener: CockatielEventToEventListenerWithData<ServicePolicy['onAvailable'], {
+        endpointUrl: string;
+    }>): ReturnType<ServicePolicy['onAvailable']>;
+    /**
+     * Makes a request to the target.
+     */
+    request<Params extends JsonRpcParams, Result extends Json>(jsonRpcRequest: Readonly<JsonRpcRequest<Params>>, fetchOptions?: FetchOptions): Promise<JsonRpcResponse<Result | null>>;
+};
+//# sourceMappingURL=rpc-service-requestable.d.mts.map

package/dist/rpc-service/rpc-service-requestable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-service-requestable.d.mts","sourceRoot":"","sources":["../../src/rpc-service/rpc-service-requestable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,mCAAmC;AAChE,OAAO,KAAK,EACV,IAAI,EACJ,aAAa,EACb,cAAc,EACd,eAAe,EAChB,wBAAwB;AAEzB,OAAO,KAAK,EACV,qCAAqC,EACrC,yBAAyB,EACzB,wBAAwB,EACxB,yBAAyB,EACzB,YAAY,EACb,qBAAoB;AAErB;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;;;OAMG;IACH,OAAO,CACL,QAAQ,EAAE,qCAAqC,CAC7C,aAAa,CAAC,SAAS,CAAC,EACxB;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CACxB,GACA,UAAU,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC;IAExC;;;;;;;OAOG;IACH,OAAO,CACL,QAAQ,EAAE,CACR,IAAI,EAAE,yBAAyB,CAC7B,wBAAwB,CACtB,yBAAyB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,EACnD;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CACxB,EACD,UAAU,CACX,KACE,IAAI,GACR,UAAU,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC;IAExC;;;;;;;OAOG;IACH,UAAU,CACR,QAAQ,EAAE,qCAAqC,CAC7C,aAAa,CAAC,YAAY,CAAC,EAC3B;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAC/C,GACA,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC;IAE3C;;;;;;OAMG;IACH,WAAW,CACT,QAAQ,EAAE,qCAAqC,CAC7C,aAAa,CAAC,aAAa,CAAC,EAC5B;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CACxB,GACA,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;IAE5C;;OAEG;IACH,OAAO,CAAC,MAAM,SAAS,aAAa,EAAE,MAAM,SAAS,IAAI,EACvD,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EAChD,YAAY,CAAC,EAAE,YAAY,GAC1B,OAAO,CAAC,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;CAC5C,CAAC"}

package/dist/rpc-service/rpc-service-requestable.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rpc-service-requestable.mjs.map

package/dist/rpc-service/rpc-service-requestable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-service-requestable.mjs","sourceRoot":"","sources":["../../src/rpc-service/rpc-service-requestable.ts"],"names":[],"mappings":"","sourcesContent":["import type { ServicePolicy } from '@metamask/controller-utils';\nimport type {\n  Json,\n  JsonRpcParams,\n  JsonRpcRequest,\n  JsonRpcResponse,\n} from '@metamask/utils';\n\nimport type {\n  CockatielEventToEventListenerWithData,\n  ExcludeCockatielEventData,\n  ExtendCockatielEventData,\n  ExtractCockatielEventData,\n  FetchOptions,\n} from './shared.js';\n\n/**\n * The interface for a service class responsible for making a request to a\n * target, whether that is a single RPC endpoint or an RPC endpoint in an RPC\n * service chain.\n *\n * @deprecated Don't use this interface (it will be removed in an upcoming major\n * version). If you need to take an \"RPC-service-like\" argument, it's best to\n * declare which properties you're interested in rather than accepting the\n * entire RPC service interface.\n */\nexport type RpcServiceRequestable = {\n  /**\n   * Listens for when the RPC service retries the request.\n   *\n   * @param listener - The callback to be called when the retry occurs.\n   * @returns What {@link ServicePolicy.onRetry} returns.\n   * @see {@link createServicePolicy}\n   */\n  onRetry(\n    listener: CockatielEventToEventListenerWithData<\n      ServicePolicy['onRetry'],\n      { endpointUrl: string }\n    >,\n  ): ReturnType<ServicePolicy['onRetry']>;\n\n  /**\n   * Listens for when the RPC service retries the request too many times in a\n   * row.\n   *\n   * @param listener - The callback to be called when the circuit is broken.\n   * @returns What {@link ServicePolicy.onBreak} returns.\n   * @see {@link createServicePolicy}\n   */\n  onBreak(\n    listener: (\n      data: ExcludeCockatielEventData<\n        ExtendCockatielEventData<\n          ExtractCockatielEventData<ServicePolicy['onBreak']>,\n          { endpointUrl: string }\n        >,\n        'isolated'\n      >,\n    ) => void,\n  ): ReturnType<ServicePolicy['onBreak']>;\n\n  /**\n   * Listens for when the policy underlying this RPC service detects a slow\n   * request.\n   *\n   * @param listener - The callback to be called when the request is slow.\n   * @returns What {@link ServicePolicy.onDegraded} returns.\n   * @see {@link createServicePolicy}\n   */\n  onDegraded(\n    listener: CockatielEventToEventListenerWithData<\n      ServicePolicy['onDegraded'],\n      { endpointUrl: string; rpcMethodName: string }\n    >,\n  ): ReturnType<ServicePolicy['onDegraded']>;\n\n  /**\n   * Listens for when the policy underlying this RPC service is available.\n   *\n   * @param listener - The callback to be called when the request is available.\n   * @returns What {@link ServicePolicy.onDegraded} returns.\n   * @see {@link createServicePolicy}\n   */\n  onAvailable(\n    listener: CockatielEventToEventListenerWithData<\n      ServicePolicy['onAvailable'],\n      { endpointUrl: string }\n    >,\n  ): ReturnType<ServicePolicy['onAvailable']>;\n\n  /**\n   * Makes a request to the target.\n   */\n  request<Params extends JsonRpcParams, Result extends Json>(\n    jsonRpcRequest: Readonly<JsonRpcRequest<Params>>,\n    fetchOptions?: FetchOptions,\n  ): Promise<JsonRpcResponse<Result | null>>;\n};\n"]}

package/dist/rpc-service/rpc-service.cjs

@@ -0,0 +1,540 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _RpcService_instances, _RpcService_currentRpcMethodName, _RpcService_currentTraceId, _RpcService_fetch, _RpcService_fetchOptions, _RpcService_logger, _RpcService_policy, _RpcService_getDefaultFetchOptions, _RpcService_getCompleteFetchOptions, _RpcService_executeAndProcessRequest;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcService = exports.isConnectionResetError = exports.isTimeoutError = exports.isHttpServerError = exports.isJsonParseError = exports.isConnectionError = exports.CUSTOM_RPC_ERRORS = exports.CONNECTION_ERRORS = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = exports.DEFAULT_MAX_RETRIES = void 0;
+const controller_utils_1 = require("@metamask/controller-utils");
+const rpc_errors_1 = require("@metamask/rpc-errors");
+const utils_1 = require("@metamask/utils");
+const cockatiel_1 = require("cockatiel");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const logger_js_1 = require("../logger.cjs");
+const log = (0, logger_js_1.createModuleLogger)(logger_js_1.projectLogger, 'RpcService');
+/**
+ * The maximum number of times that a failing service should be re-run before
+ * giving up.
+ *
+ * Note: This is not used in production and should be removed.
+ */
+exports.DEFAULT_MAX_RETRIES = 4;
+/**
+ * The maximum number of times that the service is allowed to fail before
+ * pausing further retries. This is set to a value such that if given a
+ * service that continually fails, the policy needs to be executed 3 times
+ * before further retries are paused.
+ */
+exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + exports.DEFAULT_MAX_RETRIES) * 3;
+/**
+ * The list of error messages that represent a failure to connect to the network.
+ *
+ * This list was derived from Sindre Sorhus's `is-network-error` package:
+ * <https://github.com/sindresorhus/is-network-error/blob/7bbfa8be9482ce1427a21fbff60e3ee1650dd091/index.js>
+ */
+exports.CONNECTION_ERRORS = [
+    // Chrome
+    {
+        constructorName: 'TypeError',
+        pattern: /network error/u,
+    },
+    // Chrome
+    {
+        constructorName: 'TypeError',
+        pattern: /Failed to fetch/u,
+    },
+    // Firefox
+    {
+        constructorName: 'TypeError',
+        pattern: /NetworkError when attempting to fetch resource\./u,
+    },
+    // Safari 16
+    {
+        constructorName: 'TypeError',
+        pattern: /The Internet connection appears to be offline\./u,
+    },
+    // Safari 17+
+    {
+        constructorName: 'TypeError',
+        pattern: /Load failed/u,
+    },
+    // `cross-fetch`
+    {
+        constructorName: 'TypeError',
+        pattern: /Network request failed/u,
+    },
+    // `node-fetch`
+    {
+        constructorName: 'FetchError',
+        pattern: /request to (.+) failed/u,
+    },
+    // Undici (Node.js)
+    {
+        constructorName: 'TypeError',
+        pattern: /fetch failed/u,
+    },
+    // Undici (Node.js)
+    {
+        constructorName: 'TypeError',
+        pattern: /terminated/u,
+    },
+];
+/**
+ * Custom JSON-RPC error codes for specific cases.
+ *
+ * These should be moved to `@metamask/rpc-errors` eventually.
+ */
+exports.CUSTOM_RPC_ERRORS = {
+    unauthorized: -32006,
+    httpClientError: -32080,
+};
+/**
+ * Determines whether the given error represents a failure to reach the network
+ * after request parameters have been validated.
+ *
+ * This is somewhat difficult to verify because JavaScript engines (and in
+ * some cases libraries) produce slightly different error messages for this
+ * particular scenario, and we need to account for this.
+ *
+ * @param error - The error.
+ * @returns True if the error indicates that the network cannot be connected to,
+ * and false otherwise.
+ */
+function isConnectionError(error) {
+    if (!(typeof error === 'object' && error !== null && 'message' in error)) {
+        return false;
+    }
+    const { message } = error;
+    return (typeof message === 'string' &&
+        !isNockError(message) &&
+        exports.CONNECTION_ERRORS.some(({ constructorName, pattern }) => {
+            return (error.constructor.name === constructorName && pattern.test(message));
+        }));
+}
+exports.isConnectionError = isConnectionError;
+/**
+ * Determines whether the given error message refers to a Nock error.
+ *
+ * It's important that if we failed to mock a request in a test, the resulting
+ * error does not cause the request to be retried so that we can see it right
+ * away.
+ *
+ * @param message - The error message to test.
+ * @returns True if the message indicates a missing Nock mock, false otherwise.
+ */
+function isNockError(message) {
+    return message.includes('Nock:');
+}
+/**
+ * Determine whether the given error message indicates a failure to parse JSON.
+ *
+ * This is different in tests vs. implementation code because it may manifest as
+ * a FetchError or a SyntaxError.
+ *
+ * @param error - The error object to test.
+ * @returns True if the error indicates a JSON parse error, false otherwise.
+ */
+function isJsonParseError(error) {
+    return (error instanceof SyntaxError ||
+        /invalid json/iu.test((0, utils_1.getErrorMessage)(error)));
+}
+exports.isJsonParseError = isJsonParseError;
+/**
+ * Determines whether the given error represents a HTTP server error
+ * (502, 503, or 504) that should be retried.
+ *
+ * @param error - The error object to test.
+ * @returns True if the error has an httpStatus of 502, 503, or 504.
+ */
+function isHttpServerError(error) {
+    return ('httpStatus' in error &&
+        (error.httpStatus === 502 ||
+            error.httpStatus === 503 ||
+            error.httpStatus === 504));
+}
+exports.isHttpServerError = isHttpServerError;
+/**
+ * Determines whether the given error has a `code` property of `ETIMEDOUT`.
+ *
+ * @param error - The error object to test.
+ * @returns True if the error code is `ETIMEDOUT`.
+ */
+function isTimeoutError(error) {
+    return (0, utils_1.hasProperty)(error, 'code') && error.code === 'ETIMEDOUT';
+}
+exports.isTimeoutError = isTimeoutError;
+/**
+ * Determines whether the given error has a `code` property of `ECONNRESET`.
+ *
+ * @param error - The error object to test.
+ * @returns True if the error code is `ECONNRESET`.
+ */
+function isConnectionResetError(error) {
+    return (0, utils_1.hasProperty)(error, 'code') && error.code === 'ECONNRESET';
+}
+exports.isConnectionResetError = isConnectionResetError;
+/**
+ * Guarantees a URL, even given a string. This is useful for checking components
+ * of that URL.
+ *
+ * @param endpointUrlOrUrlString - Either a URL object or a string that
+ * represents the URL of an endpoint.
+ * @returns A URL object.
+ */
+function getNormalizedEndpointUrl(endpointUrlOrUrlString) {
+    return endpointUrlOrUrlString instanceof URL
+        ? endpointUrlOrUrlString
+        : new URL(endpointUrlOrUrlString);
+}
+/**
+ * Strips username and password from a URL.
+ *
+ * @param url - The URL to strip credentials from.
+ * @returns A new URL object with credentials removed.
+ */
+function stripCredentialsFromUrl(url) {
+    const strippedUrl = new URL(url.toString());
+    strippedUrl.username = '';
+    strippedUrl.password = '';
+    return strippedUrl;
+}
+const INFURA_NON_FAILURE_HTTP_STATUS_CODES = [400, 429];
+/**
+ * Predicate function that determines if an error from Infura is treated as a service failure.
+ *
+ * @param error - The error.
+ * @returns True if the error should be treated as a service policy failure. Most errors are treated like failures,
+ * with the exception of certain HTTP status codes.
+ */
+function isServiceFailureInfura(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        (0, utils_1.hasProperty)(error, 'httpStatus') &&
+        typeof error.httpStatus === 'number') {
+        return !INFURA_NON_FAILURE_HTTP_STATUS_CODES.includes(error.httpStatus);
+    }
+    // If the error is not an object, or doesn't have a numeric httpStatus
+    // property, consider it a service failure (e.g., network errors, timeouts,
+    // etc.)
+    return true;
+}
+/**
+ * This class is responsible for making a request to an endpoint that implements
+ * the JSON-RPC protocol. It is designed to gracefully handle network and server
+ * failures, retrying requests using exponential backoff. It also offers a hook
+ * which can used to respond to slow requests.
+ */
+class RpcService {
+    /**
+     * Constructs a new RpcService object.
+     *
+     * @param options - The options. See {@link RpcServiceOptions}.
+     */
+    constructor(options) {
+        _RpcService_instances.add(this);
+        /**
+         * The RPC method name of the current request being processed. This is passed
+         * to `onDegraded` event listeners.
+         *
+         * Initialised to `''` so the type is `string` throughout the event chain.
+         * The empty string is unreachable in practice because the method name is
+         * guaranteed to be set after the current request is completed but before
+         * any `onDegraded` callbacks are called.
+         */
+        _RpcService_currentRpcMethodName.set(this, '');
+        /**
+         * The trace ID from the `X-Trace-Id` response header of the most recent
+         * request. Passed to `onDegraded` event listeners for debugging.
+         *
+         * `undefined` when no response has been received yet or when the response
+         * did not include the header.
+         */
+        _RpcService_currentTraceId.set(this, void 0);
+        /**
+         * The function used to make an HTTP request.
+         */
+        _RpcService_fetch.set(this, void 0);
+        /**
+         * A common set of options that the request options will extend.
+         */
+        _RpcService_fetchOptions.set(this, void 0);
+        /**
+         * A `loglevel` logger.
+         */
+        _RpcService_logger.set(this, void 0);
+        /**
+         * The policy that wraps the request.
+         */
+        _RpcService_policy.set(this, void 0);
+        const { btoa: givenBtoa, endpointUrl, fetch: givenFetch, logger, fetchOptions = {}, policyOptions = {}, isOffline, } = options;
+        __classPrivateFieldSet(this, _RpcService_fetch, givenFetch, "f");
+        const normalizedUrl = getNormalizedEndpointUrl(endpointUrl);
+        __classPrivateFieldSet(this, _RpcService_fetchOptions, __classPrivateFieldGet(this, _RpcService_instances, "m", _RpcService_getDefaultFetchOptions).call(this, normalizedUrl, fetchOptions, givenBtoa), "f");
+        this.endpointUrl = stripCredentialsFromUrl(normalizedUrl);
+        __classPrivateFieldSet(this, _RpcService_logger, logger, "f");
+        const isInfura = normalizedUrl.hostname.endsWith('.infura.io');
+        __classPrivateFieldSet(this, _RpcService_policy, (0, controller_utils_1.createServicePolicy)({
+            maxRetries: exports.DEFAULT_MAX_RETRIES,
+            maxConsecutiveFailures: exports.DEFAULT_MAX_CONSECUTIVE_FAILURES,
+            ...policyOptions,
+            isServiceFailure: isInfura ? isServiceFailureInfura : undefined,
+            retryFilterPolicy: (0, controller_utils_1.handleWhen)((error) => {
+                // If user is offline, don't retry any errors
+                // This prevents degraded/break callbacks from being triggered
+                if (isOffline()) {
+                    return false;
+                }
+                return (
+                // Ignore errors where the request failed to establish
+                isConnectionError(error) ||
+                    // Ignore server sent HTML error pages or truncated JSON responses
+                    isJsonParseError(error) ||
+                    // Ignore server overload errors
+                    isHttpServerError(error) ||
+                    // Ignore timeout errors
+                    isTimeoutError(error) ||
+                    // Ignore connection reset errors
+                    isConnectionResetError(error));
+            }),
+        }), "f");
+    }
+    /**
+     * Resets the underlying composite Cockatiel policy.
+     *
+     * This is useful in a collection of RpcServices where some act as failovers
+     * for others where you effectively want to invalidate the failovers when the
+     * primary recovers.
+     */
+    resetPolicy() {
+        __classPrivateFieldGet(this, _RpcService_policy, "f").reset();
+    }
+    /**
+     * @returns The state of the underlying circuit.
+     */
+    getCircuitState() {
+        return __classPrivateFieldGet(this, _RpcService_policy, "f").getCircuitState();
+    }
+    /**
+     * Listens for when the RPC service retries the request.
+     *
+     * @param listener - The callback to be called when the retry occurs.
+     * @returns What {@link ServicePolicy.onRetry} returns.
+     * @see {@link createServicePolicy}
+     */
+    onRetry(listener) {
+        return __classPrivateFieldGet(this, _RpcService_policy, "f").onRetry((data) => {
+            listener({ ...data, endpointUrl: this.endpointUrl.toString() });
+        });
+    }
+    /**
+     * Listens for when the RPC service retries the request too many times in a
+     * row, causing the underlying circuit to break.
+     *
+     * @param listener - The callback to be called when the circuit is broken.
+     * @returns What {@link ServicePolicy.onBreak} returns.
+     * @see {@link createServicePolicy}
+     */
+    onBreak(listener) {
+        return __classPrivateFieldGet(this, _RpcService_policy, "f").onBreak((data) => {
+            // `{ isolated: true }` is a special object that shows up when `isolate`
+            // is called on the circuit breaker. Usually `isolate` is used to hold the
+            // circuit open, but we (ab)use this method in `createServicePolicy` to
+            // reset the circuit breaker policy. When we do this, we don't want to
+            // call `onBreak` handlers, because then it causes
+            // `NetworkController:rpcEndpointUnavailable` and
+            // `NetworkController:rpcEndpointChainUnavailable` to be published. So we
+            // have to ignore that object here. The consequence is that `isolate`
+            // doesn't function the way it is intended, at least in the context of an
+            // RpcService. However, we are making a bet that we won't need to use it
+            // other than how we are already using it.
+            if (!('isolated' in data)) {
+                listener({
+                    ...data,
+                    endpointUrl: this.endpointUrl.toString(),
+                });
+            }
+        });
+    }
+    /**
+     * Listens for when the policy underlying this RPC service detects a slow
+     * request.
+     *
+     * @param listener - The callback to be called when the request is slow.
+     * @returns What {@link ServicePolicy.onDegraded} returns.
+     * @see {@link createServicePolicy}
+     */
+    onDegraded(listener) {
+        return __classPrivateFieldGet(this, _RpcService_policy, "f").onDegraded((data) => {
+            listener({
+                ...data,
+                endpointUrl: this.endpointUrl.toString(),
+                rpcMethodName: __classPrivateFieldGet(this, _RpcService_currentRpcMethodName, "f"),
+                traceId: __classPrivateFieldGet(this, _RpcService_currentTraceId, "f"),
+            });
+        });
+    }
+    /**
+     * Listens for when the policy underlying this RPC service is available.
+     *
+     * @param listener - The callback to be called when the request is available.
+     * @returns What {@link ServicePolicy.onAvailable} returns.
+     * @see {@link createServicePolicy}
+     */
+    onAvailable(listener) {
+        return __classPrivateFieldGet(this, _RpcService_policy, "f").onAvailable(() => {
+            listener({ endpointUrl: this.endpointUrl.toString() });
+        });
+    }
+    async request(
+    // The request object may be frozen and must not be mutated.
+    jsonRpcRequest, fetchOptions = {}) {
+        const completeFetchOptions = __classPrivateFieldGet(this, _RpcService_instances, "m", _RpcService_getCompleteFetchOptions).call(this, jsonRpcRequest, fetchOptions);
+        return await __classPrivateFieldGet(this, _RpcService_instances, "m", _RpcService_executeAndProcessRequest).call(this, completeFetchOptions, jsonRpcRequest.method);
+    }
+}
+exports.RpcService = RpcService;
+_RpcService_currentRpcMethodName = new WeakMap(), _RpcService_currentTraceId = new WeakMap(), _RpcService_fetch = new WeakMap(), _RpcService_fetchOptions = new WeakMap(), _RpcService_logger = new WeakMap(), _RpcService_policy = new WeakMap(), _RpcService_instances = new WeakSet(), _RpcService_getDefaultFetchOptions = function _RpcService_getDefaultFetchOptions(endpointUrl, fetchOptions, givenBtoa) {
+    if (endpointUrl.username && endpointUrl.password) {
+        const authString = `${endpointUrl.username}:${endpointUrl.password}`;
+        const encodedCredentials = givenBtoa(authString);
+        return (0, deepmerge_1.default)(fetchOptions, {
+            headers: { Authorization: `Basic ${encodedCredentials}` },
+        });
+    }
+    return fetchOptions;
+}, _RpcService_getCompleteFetchOptions = function _RpcService_getCompleteFetchOptions(jsonRpcRequest, fetchOptions) {
+    const defaultOptions = {
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        },
+    };
+    const mergedOptions = (0, deepmerge_1.default)(defaultOptions, (0, deepmerge_1.default)(__classPrivateFieldGet(this, _RpcService_fetchOptions, "f"), fetchOptions));
+    const { id, jsonrpc, method, params } = jsonRpcRequest;
+    const body = JSON.stringify({
+        id,
+        jsonrpc,
+        method,
+        params,
+    });
+    return { ...mergedOptions, body };
+}, _RpcService_executeAndProcessRequest = 
+/**
+ * Makes the request using the Cockatiel policy that this service creates.
+ *
+ * @param fetchOptions - The options for `fetch`; will be combined with the
+ * fetch options passed to the constructor
+ * @param rpcMethodName - The JSON-RPC method name of the current request.
+ * @returns The decoded JSON-RPC response from the endpoint.
+ * @throws An "authorized" JSON-RPC error (code -32006) if the response HTTP status is 401.
+ * @throws A "rate limiting" JSON-RPC error (code -32005) if the response HTTP status is 429.
+ * @throws A "resource unavailable" JSON-RPC error (code -32002) if the response HTTP status is 402, 404, or any 5xx.
+ * @throws A generic HTTP client JSON-RPC error (code -32050) for any other 4xx HTTP status codes.
+ * @throws A "parse" JSON-RPC error (code -32700) if the response is not valid JSON.
+ */
+async function _RpcService_executeAndProcessRequest(fetchOptions, rpcMethodName) {
+    let response;
+    try {
+        log(`[${this.endpointUrl}] Circuit state`, __classPrivateFieldGet(this, _RpcService_policy, "f").getCircuitState());
+        const jsonDecodedResponse = await __classPrivateFieldGet(this, _RpcService_policy, "f").execute(async (context) => {
+            // Reset response so that if this attempt throws before
+            // assigning a new response, the finally block does not read
+            // a stale response from a previous attempt.
+            response = undefined;
+            try {
+                log('REQUEST INITIATED:', this.endpointUrl.toString(), '::', fetchOptions, 
+                // @ts-expect-error This property _is_ here, the type of
+                // ServicePolicy is just wrong.
+                `(attempt ${context.attempt + 1})`);
+                response = await __classPrivateFieldGet(this, _RpcService_fetch, "f").call(this, this.endpointUrl, fetchOptions);
+                if (!response.ok) {
+                    throw new controller_utils_1.HttpError(response.status);
+                }
+                log('REQUEST SUCCESSFUL:', this.endpointUrl.toString(), response.status);
+                return await response.json();
+            }
+            finally {
+                // Track the RPC method and trace ID for the request that has just
+                // taken place. We pass these properties to `onDegraded` event
+                // listeners.
+                //
+                // We set these properties after the request completes and not
+                // before the request starts to account for race conditions. That
+                // is, if there are two requests that are being performed
+                // concurrently, and the second request fails fast but the first
+                // request succeeds slowly, when `onDegraded` is called we want it
+                // to include the first request as the RPC method, not the second.
+                //
+                // Also, we set these properties within a `finally` block inside of
+                // the function passed to `policy.execute` to ensure that they are
+                // set before `onDegraded` gets called, no matter the outcome of
+                // the request.
+                __classPrivateFieldSet(this, _RpcService_currentRpcMethodName, rpcMethodName, "f");
+                __classPrivateFieldSet(this, _RpcService_currentTraceId, response?.headers.get('X-Trace-Id') ?? undefined, "f");
+            }
+        });
+        this.lastError = undefined;
+        return jsonDecodedResponse;
+    }
+    catch (error) {
+        log('REQUEST ERROR:', this.endpointUrl.toString(), error);
+        this.lastError =
+            error instanceof Error ? error : new Error((0, utils_1.getErrorMessage)(error));
+        if (error instanceof controller_utils_1.HttpError) {
+            const status = error.httpStatus;
+            if (status === 401) {
+                throw new rpc_errors_1.JsonRpcError(exports.CUSTOM_RPC_ERRORS.unauthorized, 'Unauthorized.', {
+                    httpStatus: status,
+                });
+            }
+            if (status === 429) {
+                throw rpc_errors_1.rpcErrors.limitExceeded({
+                    message: 'Request is being rate limited.',
+                    data: {
+                        httpStatus: status,
+                    },
+                });
+            }
+            if (status >= 500 || status === 402 || status === 404) {
+                throw rpc_errors_1.rpcErrors.resourceUnavailable({
+                    message: 'RPC endpoint not found or unavailable.',
+                    data: {
+                        httpStatus: status,
+                    },
+                });
+            }
+            // Handle all other 4xx errors as generic HTTP client errors
+            throw new rpc_errors_1.JsonRpcError(exports.CUSTOM_RPC_ERRORS.httpClientError, 'RPC endpoint returned HTTP client error.', {
+                httpStatus: status,
+            });
+        }
+        else if (isJsonParseError(error)) {
+            throw rpc_errors_1.rpcErrors.parse({
+                message: 'RPC endpoint did not return JSON.',
+            });
+        }
+        else if (error instanceof controller_utils_1.BrokenCircuitError) {
+            __classPrivateFieldGet(this, _RpcService_logger, "f")?.warn(error);
+            const remainingCircuitOpenDuration = __classPrivateFieldGet(this, _RpcService_policy, "f").getRemainingCircuitOpenDuration();
+            const formattedRemainingCircuitOpenDuration = Intl.NumberFormat(undefined, { maximumFractionDigits: 2 }).format((remainingCircuitOpenDuration ?? __classPrivateFieldGet(this, _RpcService_policy, "f").circuitBreakDuration) /
+                utils_1.Duration.Minute);
+            throw rpc_errors_1.rpcErrors.resourceUnavailable({
+                message: `RPC endpoint returned too many errors, retrying in ${formattedRemainingCircuitOpenDuration} minutes. Consider using a different RPC endpoint.`,
+            });
+        }
+        throw error;
+    }
+};
+//# sourceMappingURL=rpc-service.cjs.map