@metamask/ramps-controller 1.0.0 → 2.1.0

package/dist/selectors.d.cts

@@ -0,0 +1,75 @@
+import type { RampsControllerState } from "./RampsController.cjs";
+/**
+ * Result shape returned by request selectors.
+ *
+ * This object is memoized - the same reference is returned when the underlying
+ * request state hasn't changed, making it safe to use with React Redux's
+ * `useSelector` without `shallowEqual`.
+ */
+export type RequestSelectorResult<TData> = {
+    /** The data returned by the request, or null if not yet loaded or on error. */
+    data: TData | null;
+    /** Whether the request is currently in progress. */
+    isFetching: boolean;
+    /** Error message if the request failed, or null if successful or not yet attempted. */
+    error: string | null;
+};
+/**
+ * Creates a memoized selector for a controller method's request state.
+ *
+ * This selector tracks the loading, error, and data state for a specific
+ * controller method call. It's optimized for use with React Redux's `useSelector`
+ * hook - the selector returns the same object reference when the underlying
+ * request state hasn't changed, so no `shallowEqual` is needed.
+ *
+ * The selector uses reference equality on the request object itself, so it
+ * works correctly with arrays and objects without expensive deep equality checks.
+ *
+ * @param getState - Function that extracts RampsControllerState from the root state.
+ *   Typically a reselect selector like `selectRampsControllerState`.
+ * @param method - The controller method name (e.g., 'updateGeolocation').
+ * @param params - The parameters passed to the method, used to generate the cache key.
+ *   Must match the params used when calling the controller method.
+ * @returns A selector function that returns `{ data, isFetching, error }`.
+ *
+ * @example
+ * ```ts
+ * // In selectors file - create once at module level
+ * import { createRequestSelector } from '@metamask/ramps-controller';
+ * import { createSelector } from 'reselect';
+ *
+ * const selectRampsControllerState = createSelector(
+ *   (state: RootState) => state.engine.backgroundState.RampsController,
+ *   (rampsControllerState) => rampsControllerState,
+ * );
+ *
+ * export const selectGeolocationRequest = createRequestSelector<
+ *   RootState,
+ *   string
+ * >(selectRampsControllerState, 'updateGeolocation', []);
+ *
+ * // In hook - use directly with useSelector, no shallowEqual needed
+ * export function useRampsGeolocation() {
+ *   const { isFetching, error } = useSelector(selectGeolocationRequest);
+ *   // ... rest of hook
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // For methods with parameters
+ * export const selectCryptoCurrenciesRequest = (region: string) =>
+ *   createRequestSelector<RootState, CryptoCurrency[]>(
+ *     selectRampsControllerState,
+ *     'getCryptoCurrencies',
+ *     [region],
+ *   );
+ *
+ * // In component
+ * const { data, isFetching, error } = useSelector(
+ *   selectCryptoCurrenciesRequest('US')
+ * );
+ * ```
+ */
+export declare function createRequestSelector<TRootState, TData>(getState: (rootState: TRootState) => RampsControllerState | undefined, method: string, params: unknown[]): (state: TRootState) => RequestSelectorResult<TData>;
+//# sourceMappingURL=selectors.d.cts.map

package/dist/selectors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.cts","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,8BAA0B;AAI9D;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI;IACzC,+EAA+E;IAC/E,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACnB,oDAAoD;IACpD,UAAU,EAAE,OAAO,CAAC;IACpB,uFAAuF;IACvF,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,KAAK,EACrD,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,oBAAoB,GAAG,SAAS,EACrE,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EAAE,GAChB,CAAC,KAAK,EAAE,UAAU,KAAK,qBAAqB,CAAC,KAAK,CAAC,CAsBrD"}

package/dist/selectors.d.mts

@@ -0,0 +1,75 @@
+import type { RampsControllerState } from "./RampsController.mjs";
+/**
+ * Result shape returned by request selectors.
+ *
+ * This object is memoized - the same reference is returned when the underlying
+ * request state hasn't changed, making it safe to use with React Redux's
+ * `useSelector` without `shallowEqual`.
+ */
+export type RequestSelectorResult<TData> = {
+    /** The data returned by the request, or null if not yet loaded or on error. */
+    data: TData | null;
+    /** Whether the request is currently in progress. */
+    isFetching: boolean;
+    /** Error message if the request failed, or null if successful or not yet attempted. */
+    error: string | null;
+};
+/**
+ * Creates a memoized selector for a controller method's request state.
+ *
+ * This selector tracks the loading, error, and data state for a specific
+ * controller method call. It's optimized for use with React Redux's `useSelector`
+ * hook - the selector returns the same object reference when the underlying
+ * request state hasn't changed, so no `shallowEqual` is needed.
+ *
+ * The selector uses reference equality on the request object itself, so it
+ * works correctly with arrays and objects without expensive deep equality checks.
+ *
+ * @param getState - Function that extracts RampsControllerState from the root state.
+ *   Typically a reselect selector like `selectRampsControllerState`.
+ * @param method - The controller method name (e.g., 'updateGeolocation').
+ * @param params - The parameters passed to the method, used to generate the cache key.
+ *   Must match the params used when calling the controller method.
+ * @returns A selector function that returns `{ data, isFetching, error }`.
+ *
+ * @example
+ * ```ts
+ * // In selectors file - create once at module level
+ * import { createRequestSelector } from '@metamask/ramps-controller';
+ * import { createSelector } from 'reselect';
+ *
+ * const selectRampsControllerState = createSelector(
+ *   (state: RootState) => state.engine.backgroundState.RampsController,
+ *   (rampsControllerState) => rampsControllerState,
+ * );
+ *
+ * export const selectGeolocationRequest = createRequestSelector<
+ *   RootState,
+ *   string
+ * >(selectRampsControllerState, 'updateGeolocation', []);
+ *
+ * // In hook - use directly with useSelector, no shallowEqual needed
+ * export function useRampsGeolocation() {
+ *   const { isFetching, error } = useSelector(selectGeolocationRequest);
+ *   // ... rest of hook
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // For methods with parameters
+ * export const selectCryptoCurrenciesRequest = (region: string) =>
+ *   createRequestSelector<RootState, CryptoCurrency[]>(
+ *     selectRampsControllerState,
+ *     'getCryptoCurrencies',
+ *     [region],
+ *   );
+ *
+ * // In component
+ * const { data, isFetching, error } = useSelector(
+ *   selectCryptoCurrenciesRequest('US')
+ * );
+ * ```
+ */
+export declare function createRequestSelector<TRootState, TData>(getState: (rootState: TRootState) => RampsControllerState | undefined, method: string, params: unknown[]): (state: TRootState) => RequestSelectorResult<TData>;
+//# sourceMappingURL=selectors.d.mts.map

package/dist/selectors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.mts","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,8BAA0B;AAI9D;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI;IACzC,+EAA+E;IAC/E,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACnB,oDAAoD;IACpD,UAAU,EAAE,OAAO,CAAC;IACpB,uFAAuF;IACvF,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,KAAK,EACrD,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,oBAAoB,GAAG,SAAS,EACrE,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EAAE,GAChB,CAAC,KAAK,EAAE,UAAU,KAAK,qBAAqB,CAAC,KAAK,CAAC,CAsBrD"}

package/dist/selectors.mjs

@@ -0,0 +1,77 @@
+import { RequestStatus, createCacheKey } from "./RequestCache.mjs";
+/**
+ * Creates a memoized selector for a controller method's request state.
+ *
+ * This selector tracks the loading, error, and data state for a specific
+ * controller method call. It's optimized for use with React Redux's `useSelector`
+ * hook - the selector returns the same object reference when the underlying
+ * request state hasn't changed, so no `shallowEqual` is needed.
+ *
+ * The selector uses reference equality on the request object itself, so it
+ * works correctly with arrays and objects without expensive deep equality checks.
+ *
+ * @param getState - Function that extracts RampsControllerState from the root state.
+ *   Typically a reselect selector like `selectRampsControllerState`.
+ * @param method - The controller method name (e.g., 'updateGeolocation').
+ * @param params - The parameters passed to the method, used to generate the cache key.
+ *   Must match the params used when calling the controller method.
+ * @returns A selector function that returns `{ data, isFetching, error }`.
+ *
+ * @example
+ * ```ts
+ * // In selectors file - create once at module level
+ * import { createRequestSelector } from '@metamask/ramps-controller';
+ * import { createSelector } from 'reselect';
+ *
+ * const selectRampsControllerState = createSelector(
+ *   (state: RootState) => state.engine.backgroundState.RampsController,
+ *   (rampsControllerState) => rampsControllerState,
+ * );
+ *
+ * export const selectGeolocationRequest = createRequestSelector<
+ *   RootState,
+ *   string
+ * >(selectRampsControllerState, 'updateGeolocation', []);
+ *
+ * // In hook - use directly with useSelector, no shallowEqual needed
+ * export function useRampsGeolocation() {
+ *   const { isFetching, error } = useSelector(selectGeolocationRequest);
+ *   // ... rest of hook
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // For methods with parameters
+ * export const selectCryptoCurrenciesRequest = (region: string) =>
+ *   createRequestSelector<RootState, CryptoCurrency[]>(
+ *     selectRampsControllerState,
+ *     'getCryptoCurrencies',
+ *     [region],
+ *   );
+ *
+ * // In component
+ * const { data, isFetching, error } = useSelector(
+ *   selectCryptoCurrenciesRequest('US')
+ * );
+ * ```
+ */
+export function createRequestSelector(getState, method, params) {
+    const cacheKey = createCacheKey(method, params);
+    let lastRequest;
+    let lastResult = null;
+    return (state) => {
+        const request = getState(state)?.requests?.[cacheKey];
+        if (request === lastRequest && lastResult !== null) {
+            return lastResult;
+        }
+        lastRequest = request;
+        lastResult = {
+            data: request?.data ?? null,
+            isFetching: request?.status === RequestStatus.LOADING,
+            error: request?.error ?? null,
+        };
+        return lastResult;
+    };
+}
+//# sourceMappingURL=selectors.mjs.map

package/dist/selectors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.mjs","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,2BAAuB;AAkB/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,UAAU,qBAAqB,CACnC,QAAqE,EACrE,MAAc,EACd,MAAiB;IAEjB,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhD,IAAI,WAAqC,CAAC;IAC1C,IAAI,UAAU,GAAwC,IAAI,CAAC;IAE3D,OAAO,CAAC,KAAiB,EAAgC,EAAE;QACzD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC;QAEtD,IAAI,OAAO,KAAK,WAAW,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;YACnD,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,WAAW,GAAG,OAAO,CAAC;QACtB,UAAU,GAAG;YACX,IAAI,EAAG,OAAO,EAAE,IAAc,IAAI,IAAI;YACtC,UAAU,EAAE,OAAO,EAAE,MAAM,KAAK,aAAa,CAAC,OAAO;YACrD,KAAK,EAAE,OAAO,EAAE,KAAK,IAAI,IAAI;SAC9B,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import type { RampsControllerState } from './RampsController';\nimport type { RequestState } from './RequestCache';\nimport { RequestStatus, createCacheKey } from './RequestCache';\n\n/**\n * Result shape returned by request selectors.\n *\n * This object is memoized - the same reference is returned when the underlying\n * request state hasn't changed, making it safe to use with React Redux's\n * `useSelector` without `shallowEqual`.\n */\nexport type RequestSelectorResult<TData> = {\n  /** The data returned by the request, or null if not yet loaded or on error. */\n  data: TData | null;\n  /** Whether the request is currently in progress. */\n  isFetching: boolean;\n  /** Error message if the request failed, or null if successful or not yet attempted. */\n  error: string | null;\n};\n\n/**\n * Creates a memoized selector for a controller method's request state.\n *\n * This selector tracks the loading, error, and data state for a specific\n * controller method call. It's optimized for use with React Redux's `useSelector`\n * hook - the selector returns the same object reference when the underlying\n * request state hasn't changed, so no `shallowEqual` is needed.\n *\n * The selector uses reference equality on the request object itself, so it\n * works correctly with arrays and objects without expensive deep equality checks.\n *\n * @param getState - Function that extracts RampsControllerState from the root state.\n *   Typically a reselect selector like `selectRampsControllerState`.\n * @param method - The controller method name (e.g., 'updateGeolocation').\n * @param params - The parameters passed to the method, used to generate the cache key.\n *   Must match the params used when calling the controller method.\n * @returns A selector function that returns `{ data, isFetching, error }`.\n *\n * @example\n * ```ts\n * // In selectors file - create once at module level\n * import { createRequestSelector } from '@metamask/ramps-controller';\n * import { createSelector } from 'reselect';\n *\n * const selectRampsControllerState = createSelector(\n *   (state: RootState) => state.engine.backgroundState.RampsController,\n *   (rampsControllerState) => rampsControllerState,\n * );\n *\n * export const selectGeolocationRequest = createRequestSelector<\n *   RootState,\n *   string\n * >(selectRampsControllerState, 'updateGeolocation', []);\n *\n * // In hook - use directly with useSelector, no shallowEqual needed\n * export function useRampsGeolocation() {\n *   const { isFetching, error } = useSelector(selectGeolocationRequest);\n *   // ... rest of hook\n * }\n * ```\n *\n * @example\n * ```ts\n * // For methods with parameters\n * export const selectCryptoCurrenciesRequest = (region: string) =>\n *   createRequestSelector<RootState, CryptoCurrency[]>(\n *     selectRampsControllerState,\n *     'getCryptoCurrencies',\n *     [region],\n *   );\n *\n * // In component\n * const { data, isFetching, error } = useSelector(\n *   selectCryptoCurrenciesRequest('US')\n * );\n * ```\n */\nexport function createRequestSelector<TRootState, TData>(\n  getState: (rootState: TRootState) => RampsControllerState | undefined,\n  method: string,\n  params: unknown[],\n): (state: TRootState) => RequestSelectorResult<TData> {\n  const cacheKey = createCacheKey(method, params);\n\n  let lastRequest: RequestState | undefined;\n  let lastResult: RequestSelectorResult<TData> | null = null;\n\n  return (state: TRootState): RequestSelectorResult<TData> => {\n    const request = getState(state)?.requests?.[cacheKey];\n\n    if (request === lastRequest && lastResult !== null) {\n      return lastResult;\n    }\n\n    lastRequest = request;\n    lastResult = {\n      data: (request?.data as TData) ?? null,\n      isFetching: request?.status === RequestStatus.LOADING,\n      error: request?.error ?? null,\n    };\n\n    return lastResult;\n  };\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/ramps-controller",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "description": "A controller for managing cryptocurrency on/off ramps functionality",
   "keywords": [
     "MetaMask",
@@ -40,6 +40,7 @@
     "build:docs": "typedoc",
     "changelog:update": "../../scripts/update-changelog.sh @metamask/ramps-controller",
     "changelog:validate": "../../scripts/validate-changelog.sh @metamask/ramps-controller",
+    "dev": "node dev-watch.js",
     "publish:preview": "yarn npm publish --tag preview",
     "since-latest-release": "../../scripts/since-latest-release.sh",
     "test": "NODE_OPTIONS=--experimental-vm-modules jest --reporters=jest-silent-reporter",
@@ -49,7 +50,7 @@
   },
   "dependencies": {
     "@metamask/base-controller": "^9.0.0",
-    "@metamask/controller-utils": "^11.16.0",
+    "@metamask/controller-utils": "^11.17.0",
     "@metamask/messenger": "^0.3.0"
   },
   "devDependencies": {

package/dist/OnRampService-method-action-types.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"OnRampService-method-action-types.cjs","sourceRoot":"","sources":["../src/OnRampService-method-action-types.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated by `scripts/generate-method-action-types.ts`.\n * Do not edit manually.\n */\n\nimport type { OnRampService } from './OnRampService';\n\n/**\n * Makes a request to the API in order to retrieve the user's geolocation\n * based on their IP address.\n *\n * @returns The user's country/region code (e.g., \"US-UT\" for Utah, USA).\n */\nexport type OnRampServiceGetGeolocationAction = {\n  type: `OnRampService:getGeolocation`;\n  handler: OnRampService['getGeolocation'];\n};\n\n/**\n * Union of all OnRampService action types.\n */\nexport type OnRampServiceMethodActions = OnRampServiceGetGeolocationAction;\n"]}

package/dist/OnRampService-method-action-types.d.cts

@@ -1,20 +0,0 @@
-/**
- * This file is auto generated by `scripts/generate-method-action-types.ts`.
- * Do not edit manually.
- */
-import type { OnRampService } from "./OnRampService.cjs";
-/**
- * Makes a request to the API in order to retrieve the user's geolocation
- * based on their IP address.
- *
- * @returns The user's country/region code (e.g., "US-UT" for Utah, USA).
- */
-export type OnRampServiceGetGeolocationAction = {
-    type: `OnRampService:getGeolocation`;
-    handler: OnRampService['getGeolocation'];
-};
-/**
- * Union of all OnRampService action types.
- */
-export type OnRampServiceMethodActions = OnRampServiceGetGeolocationAction;
-//# sourceMappingURL=OnRampService-method-action-types.d.cts.map

package/dist/OnRampService-method-action-types.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OnRampService-method-action-types.d.cts","sourceRoot":"","sources":["../src/OnRampService-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,4BAAwB;AAErD;;;;;GAKG;AACH,MAAM,MAAM,iCAAiC,GAAG;IAC9C,IAAI,EAAE,8BAA8B,CAAC;IACrC,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;CAC1C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,iCAAiC,CAAC"}

package/dist/OnRampService-method-action-types.d.mts

@@ -1,20 +0,0 @@
-/**
- * This file is auto generated by `scripts/generate-method-action-types.ts`.
- * Do not edit manually.
- */
-import type { OnRampService } from "./OnRampService.mjs";
-/**
- * Makes a request to the API in order to retrieve the user's geolocation
- * based on their IP address.
- *
- * @returns The user's country/region code (e.g., "US-UT" for Utah, USA).
- */
-export type OnRampServiceGetGeolocationAction = {
-    type: `OnRampService:getGeolocation`;
-    handler: OnRampService['getGeolocation'];
-};
-/**
- * Union of all OnRampService action types.
- */
-export type OnRampServiceMethodActions = OnRampServiceGetGeolocationAction;
-//# sourceMappingURL=OnRampService-method-action-types.d.mts.map

package/dist/OnRampService-method-action-types.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OnRampService-method-action-types.d.mts","sourceRoot":"","sources":["../src/OnRampService-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,4BAAwB;AAErD;;;;;GAKG;AACH,MAAM,MAAM,iCAAiC,GAAG;IAC9C,IAAI,EAAE,8BAA8B,CAAC;IACrC,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;CAC1C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,iCAAiC,CAAC"}

package/dist/OnRampService-method-action-types.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"OnRampService-method-action-types.mjs","sourceRoot":"","sources":["../src/OnRampService-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated by `scripts/generate-method-action-types.ts`.\n * Do not edit manually.\n */\n\nimport type { OnRampService } from './OnRampService';\n\n/**\n * Makes a request to the API in order to retrieve the user's geolocation\n * based on their IP address.\n *\n * @returns The user's country/region code (e.g., \"US-UT\" for Utah, USA).\n */\nexport type OnRampServiceGetGeolocationAction = {\n  type: `OnRampService:getGeolocation`;\n  handler: OnRampService['getGeolocation'];\n};\n\n/**\n * Union of all OnRampService action types.\n */\nexport type OnRampServiceMethodActions = OnRampServiceGetGeolocationAction;\n"]}

package/dist/OnRampService.cjs

@@ -1,204 +0,0 @@
-"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 _a, _OnRampService_messenger, _OnRampService_fetch, _OnRampService_policy, _OnRampService_baseUrl;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnRampService = exports.OnRampEnvironment = exports.serviceName = void 0;
-const controller_utils_1 = require("@metamask/controller-utils");
-// === GENERAL ===
-/**
- * The name of the {@link OnRampService}, used to namespace the
- * service's actions and events.
- */
-exports.serviceName = 'OnRampService';
-/**
- * The environment to use for API requests.
- */
-var OnRampEnvironment;
-(function (OnRampEnvironment) {
-    OnRampEnvironment["Production"] = "production";
-    OnRampEnvironment["Staging"] = "staging";
-    OnRampEnvironment["Development"] = "development";
-})(OnRampEnvironment || (exports.OnRampEnvironment = OnRampEnvironment = {}));
-// === MESSENGER ===
-const MESSENGER_EXPOSED_METHODS = ['getGeolocation'];
-// === SERVICE DEFINITION ===
-/**
- * Gets the base URL for API requests based on the environment.
- *
- * @param environment - The environment to use.
- * @returns The base URL for API requests.
- */
-function getBaseUrl(environment) {
-    switch (environment) {
-        case OnRampEnvironment.Production:
-            return 'https://on-ramp.api.cx.metamask.io';
-        case OnRampEnvironment.Staging:
-            return 'https://on-ramp.uat-api.cx.metamask.io';
-        case OnRampEnvironment.Development:
-            return 'http://localhost:3000';
-        default:
-            throw new Error(`Invalid environment: ${String(environment)}`);
-    }
-}
-/**
- * This service object is responsible for interacting with the OnRamp API.
- *
- * @example
- *
- * ``` ts
- * import { Messenger } from '@metamask/messenger';
- * import type {
- *   OnRampServiceActions,
- *   OnRampServiceEvents,
- * } from '@metamask/ramps-controller';
- *
- * const rootMessenger = new Messenger<
- *   'Root',
- *   OnRampServiceActions
- *   OnRampServiceEvents
- * >({ namespace: 'Root' });
- * const onRampServiceMessenger = new Messenger<
- *   'OnRampService',
- *   OnRampServiceActions,
- *   OnRampServiceEvents,
- *   typeof rootMessenger,
- * >({
- *   namespace: 'OnRampService',
- *   parent: rootMessenger,
- * });
- * // Instantiate the service to register its actions on the messenger
- * new OnRampService({
- *   messenger: onRampServiceMessenger,
- *   environment: OnRampEnvironment.Production,
- *   fetch,
- * });
- *
- * // Later...
- * // Get the user's geolocation
- * const geolocation = await rootMessenger.call(
- *   'OnRampService:getGeolocation',
- * );
- * // ... Do something with the geolocation ...
- * ```
- */
-class OnRampService {
-    /**
-     * Constructs a new OnRampService object.
-     *
-     * @param args - The constructor arguments.
-     * @param args.messenger - The messenger suited for this service.
-     * @param args.environment - The environment to use for API requests.
-     * @param args.fetch - A function that can be used to make an HTTP request. If
-     * your JavaScript environment supports `fetch` natively, you'll probably want
-     * to pass that; otherwise you can pass an equivalent (such as `fetch` via
-     * `node-fetch`).
-     * @param args.policyOptions - Options to pass to `createServicePolicy`, which
-     * is used to wrap each request. See {@link CreateServicePolicyOptions}.
-     */
-    constructor({ messenger, environment = OnRampEnvironment.Staging, fetch: fetchFunction, policyOptions = {}, }) {
-        /**
-         * The messenger suited for this service.
-         */
-        _OnRampService_messenger.set(this, void 0);
-        /**
-         * A function that can be used to make an HTTP request.
-         */
-        _OnRampService_fetch.set(this, void 0);
-        /**
-         * The policy that wraps the request.
-         *
-         * @see {@link createServicePolicy}
-         */
-        _OnRampService_policy.set(this, void 0);
-        /**
-         * The base URL for API requests.
-         */
-        _OnRampService_baseUrl.set(this, void 0);
-        this.name = exports.serviceName;
-        __classPrivateFieldSet(this, _OnRampService_messenger, messenger, "f");
-        __classPrivateFieldSet(this, _OnRampService_fetch, fetchFunction, "f");
-        __classPrivateFieldSet(this, _OnRampService_policy, (0, controller_utils_1.createServicePolicy)(policyOptions), "f");
-        __classPrivateFieldSet(this, _OnRampService_baseUrl, getBaseUrl(environment), "f");
-        __classPrivateFieldGet(this, _OnRampService_messenger, "f").registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
-    }
-    /**
-     * Registers a handler that will be called after a request returns a non-500
-     * response, causing a retry. Primarily useful in tests where timers are being
-     * mocked.
-     *
-     * @param listener - The handler to be called.
-     * @returns An object that can be used to unregister the handler. See
-     * {@link CockatielEvent}.
-     * @see {@link createServicePolicy}
-     */
-    onRetry(listener) {
-        return __classPrivateFieldGet(this, _OnRampService_policy, "f").onRetry(listener);
-    }
-    /**
-     * Registers a handler that will be called after a set number of retry rounds
-     * prove that requests to the API endpoint consistently return a 5xx response.
-     *
-     * @param listener - The handler to be called.
-     * @returns An object that can be used to unregister the handler. See
-     * {@link CockatielEvent}.
-     * @see {@link createServicePolicy}
-     */
-    onBreak(listener) {
-        return __classPrivateFieldGet(this, _OnRampService_policy, "f").onBreak(listener);
-    }
-    /**
-     * Registers a handler that will be called under one of two circumstances:
-     *
-     * 1. After a set number of retries prove that requests to the API
-     * consistently result in one of the following failures:
-     *    1. A connection initiation error
-     *    2. A connection reset error
-     *    3. A timeout error
-     *    4. A non-JSON response
-     *    5. A 502, 503, or 504 response
-     * 2. After a successful request is made to the API, but the response takes
-     * longer than a set duration to return.
-     *
-     * @param listener - The handler to be called.
-     * @returns An object that can be used to unregister the handler. See
-     * {@link CockatielEvent}.
-     */
-    onDegraded(listener) {
-        return __classPrivateFieldGet(this, _OnRampService_policy, "f").onDegraded(listener);
-    }
-    /**
-     * Makes a request to the API in order to retrieve the user's geolocation
-     * based on their IP address.
-     *
-     * @returns The user's country/region code (e.g., "US-UT" for Utah, USA).
-     */
-    async getGeolocation() {
-        const response = await __classPrivateFieldGet(this, _OnRampService_policy, "f").execute(async () => {
-            const url = new URL('geolocation', __classPrivateFieldGet(this, _OnRampService_baseUrl, "f"));
-            const localResponse = await __classPrivateFieldGet(this, _OnRampService_fetch, "f").call(this, url);
-            if (!localResponse.ok) {
-                throw new controller_utils_1.HttpError(localResponse.status, `Fetching '${url.toString()}' failed with status '${localResponse.status}'`);
-            }
-            return localResponse;
-        });
-        const textResponse = await response.text();
-        const trimmedResponse = textResponse.trim();
-        if (trimmedResponse.length > 0) {
-            return trimmedResponse;
-        }
-        throw new Error('Malformed response received from geolocation API');
-    }
-}
-exports.OnRampService = OnRampService;
-_a = OnRampService, _OnRampService_messenger = new WeakMap(), _OnRampService_fetch = new WeakMap(), _OnRampService_policy = new WeakMap(), _OnRampService_baseUrl = new WeakMap();
-//# sourceMappingURL=OnRampService.cjs.map

package/dist/OnRampService.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"OnRampService.cjs","sourceRoot":"","sources":["../src/OnRampService.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  CreateServicePolicyOptions,\n  ServicePolicy,\n} from '@metamask/controller-utils';\nimport { createServicePolicy, HttpError } from '@metamask/controller-utils';\nimport type { Messenger } from '@metamask/messenger';\n\nimport type { OnRampServiceMethodActions } from './OnRampService-method-action-types';\n\n// === GENERAL ===\n\n/**\n * The name of the {@link OnRampService}, used to namespace the\n * service's actions and events.\n */\nexport const serviceName = 'OnRampService';\n\n/**\n * The environment to use for API requests.\n */\nexport enum OnRampEnvironment {\n  Production = 'production',\n  Staging = 'staging',\n  Development = 'development',\n}\n\n// === MESSENGER ===\n\nconst MESSENGER_EXPOSED_METHODS = ['getGeolocation'] as const;\n\n/**\n * Actions that {@link OnRampService} exposes to other consumers.\n */\nexport type OnRampServiceActions = OnRampServiceMethodActions;\n\n/**\n * Actions from other messengers that {@link OnRampService} calls.\n */\ntype AllowedActions = never;\n\n/**\n * Events that {@link OnRampService} exposes to other consumers.\n */\nexport type OnRampServiceEvents = never;\n\n/**\n * Events from other messengers that {@link OnRampService} subscribes to.\n */\ntype AllowedEvents = never;\n\n/**\n * The messenger which is restricted to actions and events accessed by\n * {@link OnRampService}.\n */\nexport type OnRampServiceMessenger = Messenger<\n  typeof serviceName,\n  OnRampServiceActions | AllowedActions,\n  OnRampServiceEvents | AllowedEvents\n>;\n\n// === SERVICE DEFINITION ===\n\n/**\n * Gets the base URL for API requests based on the environment.\n *\n * @param environment - The environment to use.\n * @returns The base URL for API requests.\n */\nfunction getBaseUrl(environment: OnRampEnvironment): string {\n  switch (environment) {\n    case OnRampEnvironment.Production:\n      return 'https://on-ramp.api.cx.metamask.io';\n    case OnRampEnvironment.Staging:\n      return 'https://on-ramp.uat-api.cx.metamask.io';\n    case OnRampEnvironment.Development:\n      return 'http://localhost:3000';\n    default:\n      throw new Error(`Invalid environment: ${String(environment)}`);\n  }\n}\n\n/**\n * This service object is responsible for interacting with the OnRamp API.\n *\n * @example\n *\n * ``` ts\n * import { Messenger } from '@metamask/messenger';\n * import type {\n *   OnRampServiceActions,\n *   OnRampServiceEvents,\n * } from '@metamask/ramps-controller';\n *\n * const rootMessenger = new Messenger<\n *   'Root',\n *   OnRampServiceActions\n *   OnRampServiceEvents\n * >({ namespace: 'Root' });\n * const onRampServiceMessenger = new Messenger<\n *   'OnRampService',\n *   OnRampServiceActions,\n *   OnRampServiceEvents,\n *   typeof rootMessenger,\n * >({\n *   namespace: 'OnRampService',\n *   parent: rootMessenger,\n * });\n * // Instantiate the service to register its actions on the messenger\n * new OnRampService({\n *   messenger: onRampServiceMessenger,\n *   environment: OnRampEnvironment.Production,\n *   fetch,\n * });\n *\n * // Later...\n * // Get the user's geolocation\n * const geolocation = await rootMessenger.call(\n *   'OnRampService:getGeolocation',\n * );\n * // ... Do something with the geolocation ...\n * ```\n */\nexport class OnRampService {\n  /**\n   * The name of the service.\n   */\n  readonly name: typeof serviceName;\n\n  /**\n   * The messenger suited for this service.\n   */\n  readonly #messenger: ConstructorParameters<\n    typeof OnRampService\n  >[0]['messenger'];\n\n  /**\n   * A function that can be used to make an HTTP request.\n   */\n  readonly #fetch: ConstructorParameters<typeof OnRampService>[0]['fetch'];\n\n  /**\n   * The policy that wraps the request.\n   *\n   * @see {@link createServicePolicy}\n   */\n  readonly #policy: ServicePolicy;\n\n  /**\n   * The base URL for API requests.\n   */\n  readonly #baseUrl: string;\n\n  /**\n   * Constructs a new OnRampService object.\n   *\n   * @param args - The constructor arguments.\n   * @param args.messenger - The messenger suited for this service.\n   * @param args.environment - The environment to use for API requests.\n   * @param args.fetch - A function that can be used to make an HTTP request. If\n   * your JavaScript environment supports `fetch` natively, you'll probably want\n   * to pass that; otherwise you can pass an equivalent (such as `fetch` via\n   * `node-fetch`).\n   * @param args.policyOptions - Options to pass to `createServicePolicy`, which\n   * is used to wrap each request. See {@link CreateServicePolicyOptions}.\n   */\n  constructor({\n    messenger,\n    environment = OnRampEnvironment.Staging,\n    fetch: fetchFunction,\n    policyOptions = {},\n  }: {\n    messenger: OnRampServiceMessenger;\n    environment?: OnRampEnvironment;\n    fetch: typeof fetch;\n    policyOptions?: CreateServicePolicyOptions;\n  }) {\n    this.name = serviceName;\n    this.#messenger = messenger;\n    this.#fetch = fetchFunction;\n    this.#policy = createServicePolicy(policyOptions);\n    this.#baseUrl = getBaseUrl(environment);\n\n    this.#messenger.registerMethodActionHandlers(\n      this,\n      MESSENGER_EXPOSED_METHODS,\n    );\n  }\n\n  /**\n   * Registers a handler that will be called after a request returns a non-500\n   * response, causing a retry. Primarily useful in tests where timers are being\n   * mocked.\n   *\n   * @param listener - The handler to be called.\n   * @returns An object that can be used to unregister the handler. See\n   * {@link CockatielEvent}.\n   * @see {@link createServicePolicy}\n   */\n  onRetry(\n    listener: Parameters<ServicePolicy['onRetry']>[0],\n  ): ReturnType<ServicePolicy['onRetry']> {\n    return this.#policy.onRetry(listener);\n  }\n\n  /**\n   * Registers a handler that will be called after a set number of retry rounds\n   * prove that requests to the API endpoint consistently return a 5xx response.\n   *\n   * @param listener - The handler to be called.\n   * @returns An object that can be used to unregister the handler. See\n   * {@link CockatielEvent}.\n   * @see {@link createServicePolicy}\n   */\n  onBreak(\n    listener: Parameters<ServicePolicy['onBreak']>[0],\n  ): ReturnType<ServicePolicy['onBreak']> {\n    return this.#policy.onBreak(listener);\n  }\n\n  /**\n   * Registers a handler that will be called under one of two circumstances:\n   *\n   * 1. After a set number of retries prove that requests to the API\n   * consistently result in one of the following failures:\n   *    1. A connection initiation error\n   *    2. A connection reset error\n   *    3. A timeout error\n   *    4. A non-JSON response\n   *    5. A 502, 503, or 504 response\n   * 2. After a successful request is made to the API, but the response takes\n   * longer than a set duration to return.\n   *\n   * @param listener - The handler to be called.\n   * @returns An object that can be used to unregister the handler. See\n   * {@link CockatielEvent}.\n   */\n  onDegraded(\n    listener: Parameters<ServicePolicy['onDegraded']>[0],\n  ): ReturnType<ServicePolicy['onDegraded']> {\n    return this.#policy.onDegraded(listener);\n  }\n\n  /**\n   * Makes a request to the API in order to retrieve the user's geolocation\n   * based on their IP address.\n   *\n   * @returns The user's country/region code (e.g., \"US-UT\" for Utah, USA).\n   */\n  async getGeolocation(): Promise<string> {\n    const response = await this.#policy.execute(async () => {\n      const url = new URL('geolocation', this.#baseUrl);\n      const localResponse = await this.#fetch(url);\n      if (!localResponse.ok) {\n        throw new HttpError(\n          localResponse.status,\n          `Fetching '${url.toString()}' failed with status '${localResponse.status}'`,\n        );\n      }\n      return localResponse;\n    });\n\n    const textResponse = await response.text();\n    const trimmedResponse = textResponse.trim();\n\n    if (trimmedResponse.length > 0) {\n      return trimmedResponse;\n    }\n\n    throw new Error('Malformed response received from geolocation API');\n  }\n}\n"]}