@metamask/profile-sync-controller 0.4.0 → 0.6.0

package/dist/chunk-5EBUFNAN.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sdk/utils/messaging-signing-snap-requests.ts"],"sourcesContent":["import type { Eip1193Provider } from 'ethers';\n\nexport type Snap = {\n  permissionName: string;\n  id: string;\n  version: string;\n  initialPermissions: Record<string, unknown>;\n};\nexport type GetSnapsResponse = Record<string, Snap>;\n\nexport const SNAP_ORIGIN = 'npm:@metamask/message-signing-snap';\n\nconst foundSnap = (snap: Snap) => snap.id === SNAP_ORIGIN;\n\n/**\n * Requests Connection to the Message Signing Snap\n *\n * @param provider - MetaMask Wallet Provider\n * @returns snap connect result\n */\nexport async function connectSnap(provider: Eip1193Provider): Promise<string> {\n  const result: string = await provider.request({\n    method: 'wallet_requestSnaps',\n    params: {\n      [SNAP_ORIGIN]: {},\n    },\n  });\n\n  return result;\n}\n\n/**\n * Gets Snaps from a MetaMask Wallet\n *\n * @param provider - MetaMask Wallet Provider\n * @returns All currently installed snaps.\n */\nexport async function getSnaps(\n  provider: Eip1193Provider,\n): Promise<GetSnapsResponse> {\n  const result: GetSnapsResponse = await provider.request({\n    method: 'wallet_getSnaps',\n  });\n\n  return result;\n}\n\n/**\n * Will return the message signing snap if installed\n * @param provider - MetaMask Wallet Provider\n */\nexport async function getSnap(\n  provider: Eip1193Provider,\n): Promise<Snap | undefined> {\n  try {\n    const snaps = await getSnaps(provider);\n    return Object.values(snaps ?? {}).find((snap) => foundSnap(snap));\n  } catch (e) {\n    console.error('Failed to obtain installed snap', e);\n    return undefined;\n  }\n}\n\nexport const MESSAGE_SIGNING_SNAP = {\n  async getPublicKey(provider: Eip1193Provider) {\n    const publicKey: string = await provider.request({\n      method: 'wallet_invokeSnap',\n      params: { snapId: SNAP_ORIGIN, request: { method: 'getPublicKey' } },\n    });\n\n    return publicKey;\n  },\n\n  async signMessage(provider: Eip1193Provider, message: `metamask:${string}`) {\n    const signedMessage: string = await provider?.request({\n      method: 'wallet_invokeSnap',\n      params: {\n        snapId: SNAP_ORIGIN,\n        request: { method: 'signMessage', params: { message } },\n      },\n    });\n\n    return signedMessage;\n  },\n};\n"],"mappings":";AAUO,IAAM,cAAc;AAE3B,IAAM,YAAY,CAAC,SAAe,KAAK,OAAO;AAQ9C,eAAsB,YAAY,UAA4C;AAC5E,QAAM,SAAiB,MAAM,SAAS,QAAQ;AAAA,IAC5C,QAAQ;AAAA,IACR,QAAQ;AAAA,MACN,CAAC,WAAW,GAAG,CAAC;AAAA,IAClB;AAAA,EACF,CAAC;AAED,SAAO;AACT;AAQA,eAAsB,SACpB,UAC2B;AAC3B,QAAM,SAA2B,MAAM,SAAS,QAAQ;AAAA,IACtD,QAAQ;AAAA,EACV,CAAC;AAED,SAAO;AACT;AAMA,eAAsB,QACpB,UAC2B;AAC3B,MAAI;AACF,UAAM,QAAQ,MAAM,SAAS,QAAQ;AACrC,WAAO,OAAO,OAAO,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,UAAU,IAAI,CAAC;AAAA,EAClE,SAAS,GAAG;AACV,YAAQ,MAAM,mCAAmC,CAAC;AAClD,WAAO;AAAA,EACT;AACF;AAEO,IAAM,uBAAuB;AAAA,EAClC,MAAM,aAAa,UAA2B;AAC5C,UAAM,YAAoB,MAAM,SAAS,QAAQ;AAAA,MAC/C,QAAQ;AAAA,MACR,QAAQ,EAAE,QAAQ,aAAa,SAAS,EAAE,QAAQ,eAAe,EAAE;AAAA,IACrE,CAAC;AAED,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,YAAY,UAA2B,SAA+B;AAC1E,UAAM,gBAAwB,MAAM,UAAU,QAAQ;AAAA,MACpD,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,QAAQ;AAAA,QACR,SAAS,EAAE,QAAQ,eAAe,QAAQ,EAAE,QAAQ,EAAE;AAAA,MACxD;AAAA,IACF,CAAC;AAED,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-5MQUI24U.js

@@ -1,47 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkBKQE7DB5js = require('./chunk-BKQE7DB5.js');
-
-// src/controllers/user-storage/schema.ts
-var ALLOW_ARBITRARY_KEYS = "ALLOW_ARBITRARY_KEYS";
-var USER_STORAGE_SCHEMA = {
-  notifications: ["notificationSettings"],
-  accounts: [ALLOW_ARBITRARY_KEYS]
-};
-var getFeatureAndKeyFromPath = (path) => {
-  const pathRegex = /^\w+\.\w+$/u;
-  if (!pathRegex.test(path)) {
-    throw new Error(
-      `user-storage - path is not in the correct format. Correct format: 'feature.key'`
-    );
-  }
-  const [feature, key] = path.split(".");
-  if (!(feature in USER_STORAGE_SCHEMA)) {
-    throw new Error(`user-storage - invalid feature provided: ${feature}`);
-  }
-  const validFeature = USER_STORAGE_SCHEMA[feature];
-  if (!validFeature.includes(key) && !validFeature.includes(ALLOW_ARBITRARY_KEYS)) {
-    const validKeys = USER_STORAGE_SCHEMA[feature].join(", ");
-    throw new Error(
-      `user-storage - invalid key provided for this feature: ${key}. Valid keys: ${validKeys}`
-    );
-  }
-  return { feature, key };
-};
-var isPathWithFeatureAndKey = (path) => {
-  const pathRegex = /^\w+\.\w+$/u;
-  return pathRegex.test(path);
-};
-function createEntryPath(path, storageKey) {
-  const { feature, key } = getFeatureAndKeyFromPath(path);
-  const hashedKey = _chunkBKQE7DB5js.createSHA256Hash.call(void 0, key + storageKey);
-  return `/${feature}/${hashedKey}`;
-}
-
-
-
-
-
-
-exports.USER_STORAGE_SCHEMA = USER_STORAGE_SCHEMA; exports.getFeatureAndKeyFromPath = getFeatureAndKeyFromPath; exports.isPathWithFeatureAndKey = isPathWithFeatureAndKey; exports.createEntryPath = createEntryPath;
-//# sourceMappingURL=chunk-5MQUI24U.js.map

package/dist/chunk-5MQUI24U.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/controllers/user-storage/schema.ts"],"names":[],"mappings":";;;;;AASA,IAAM,uBAAuB;AAEtB,IAAM,sBAAsB;AAAA,EACjC,eAAe,CAAC,sBAAsB;AAAA,EACtC,UAAU,CAAC,oBAAoB;AACjC;AAoBO,IAAM,2BAA2B,CACtC,SAC6B;AAC7B,QAAM,YAAY;AAElB,MAAI,CAAC,UAAU,KAAK,IAAI,GAAG;AACzB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,CAAC,SAAS,GAAG,IAAI,KAAK,MAAM,GAAG;AAKrC,MAAI,EAAE,WAAW,sBAAsB;AACrC,UAAM,IAAI,MAAM,4CAA4C,OAAO,EAAE;AAAA,EACvE;AAEA,QAAM,eAAe,oBAAoB,OAAO;AAEhD,MACE,CAAC,aAAa,SAAS,GAAG,KAC1B,CAAC,aAAa,SAAS,oBAAoB,GAC3C;AACA,UAAM,YAAY,oBAAoB,OAAO,EAAE,KAAK,IAAI;AAExD,UAAM,IAAI;AAAA,MACR,yDAAyD,GAAG,iBAAiB,SAAS;AAAA,IACxF;AAAA,EACF;AAEA,SAAO,EAAE,SAAS,IAAI;AACxB;AAEO,IAAM,0BAA0B,CACrC,SAC6C;AAC7C,QAAM,YAAY;AAElB,SAAO,UAAU,KAAK,IAAI;AAC5B;AAWO,SAAS,gBACd,MACA,YACQ;AACR,QAAM,EAAE,SAAS,IAAI,IAAI,yBAAyB,IAAI;AACtD,QAAM,YAAY,iBAAiB,MAAM,UAAU;AAEnD,SAAO,IAAI,OAAO,IAAI,SAAS;AACjC","sourcesContent":["import { createSHA256Hash } from './encryption';\n\n/**\n * The User Storage Endpoint requires a feature name and a namespace key.\n * Developers can provide additional features and keys by extending these types below.\n *\n * Adding ALLOW_ARBITRARY_KEYS as the first key in the array allows for any key to be used for this feature.\n * This can be useful for features where keys are not deterministic (eg. accounts addresses).\n */\nconst ALLOW_ARBITRARY_KEYS = 'ALLOW_ARBITRARY_KEYS' as const;\n\nexport const USER_STORAGE_SCHEMA = {\n  notifications: ['notificationSettings'],\n  accounts: [ALLOW_ARBITRARY_KEYS],\n} as const;\n\ntype UserStorageSchema = typeof USER_STORAGE_SCHEMA;\n\ntype UserStorageFeatures = keyof UserStorageSchema;\ntype UserStorageFeatureKeys<Feature extends UserStorageFeatures> =\n  UserStorageSchema[Feature][0] extends typeof ALLOW_ARBITRARY_KEYS\n    ? string\n    : UserStorageSchema[Feature][number];\n\ntype UserStorageFeatureAndKey = {\n  feature: UserStorageFeatures;\n  key: UserStorageFeatureKeys<UserStorageFeatures>;\n};\n\nexport type UserStoragePathWithFeatureOnly = keyof UserStorageSchema;\nexport type UserStoragePathWithFeatureAndKey = {\n  [K in UserStorageFeatures]: `${K}.${UserStorageFeatureKeys<K>}`;\n}[UserStoragePathWithFeatureOnly];\n\nexport const getFeatureAndKeyFromPath = (\n  path: UserStoragePathWithFeatureAndKey,\n): UserStorageFeatureAndKey => {\n  const pathRegex = /^\\w+\\.\\w+$/u;\n\n  if (!pathRegex.test(path)) {\n    throw new Error(\n      `user-storage - path is not in the correct format. Correct format: 'feature.key'`,\n    );\n  }\n\n  const [feature, key] = path.split('.') as [\n    UserStorageFeatures,\n    UserStorageFeatureKeys<UserStorageFeatures>,\n  ];\n\n  if (!(feature in USER_STORAGE_SCHEMA)) {\n    throw new Error(`user-storage - invalid feature provided: ${feature}`);\n  }\n\n  const validFeature = USER_STORAGE_SCHEMA[feature] as readonly string[];\n\n  if (\n    !validFeature.includes(key) &&\n    !validFeature.includes(ALLOW_ARBITRARY_KEYS)\n  ) {\n    const validKeys = USER_STORAGE_SCHEMA[feature].join(', ');\n\n    throw new Error(\n      `user-storage - invalid key provided for this feature: ${key}. Valid keys: ${validKeys}`,\n    );\n  }\n\n  return { feature, key };\n};\n\nexport const isPathWithFeatureAndKey = (\n  path: string,\n): path is UserStoragePathWithFeatureAndKey => {\n  const pathRegex = /^\\w+\\.\\w+$/u;\n\n  return pathRegex.test(path);\n};\n\n/**\n * Constructs a unique entry path for a user.\n * This can be done due to the uniqueness of the storage key (no users will share the same storage key).\n * The users entry is a unique hash that cannot be reversed.\n *\n * @param path - string in the form of `${feature}.${key}` that matches schema\n * @param storageKey - users storage key\n * @returns path to store entry\n */\nexport function createEntryPath(\n  path: UserStoragePathWithFeatureAndKey,\n  storageKey: string,\n): string {\n  const { feature, key } = getFeatureAndKeyFromPath(path);\n  const hashedKey = createSHA256Hash(key + storageKey);\n\n  return `/${feature}/${hashedKey}`;\n}\n"]}

package/dist/chunk-5XSXZTED.mjs

@@ -1,57 +0,0 @@
-// src/sdk/utils/eip-6963-metamask-provider.ts
-var metamaskClientsRdns = {
-  main: "io.metamask",
-  flask: "io.metamask.flask",
-  institutional: "io.metamask.mmi"
-};
-var providerCache = {};
-function getMetaMaskProviderEIP6963(type = "any") {
-  return new Promise((res) => {
-    if (type !== "any" && metamaskClientsRdns[type] === void 0) {
-      res(null);
-      return;
-    }
-    const cachedProvider = providerCache[type];
-    if (cachedProvider) {
-      res(cachedProvider);
-      return;
-    }
-    const providers = [];
-    const handleProviderEvent = (event) => {
-      const typedEvent = event;
-      const providerDetail = typedEvent?.detail;
-      if (providerDetail?.provider && providerDetail?.info?.rdns) {
-        providers.push({
-          rdns: providerDetail?.info?.rdns,
-          provider: providerDetail?.provider
-        });
-      }
-    };
-    window.addEventListener("eip6963:announceProvider", handleProviderEvent);
-    window.dispatchEvent(new Event("eip6963:requestProvider"));
-    setTimeout(() => {
-      window.removeEventListener(
-        "eip6963:announceProvider",
-        handleProviderEvent
-      );
-      let provider;
-      if (type === "any") {
-        const metamaskClients = Object.values(metamaskClientsRdns);
-        provider = providers.find((p) => metamaskClients.includes(p.rdns))?.provider ?? null;
-      } else {
-        const metamaskRdns = metamaskClientsRdns[type];
-        provider = providers.find((p) => p.rdns === metamaskRdns)?.provider ?? null;
-      }
-      if (provider) {
-        providerCache[type] = provider;
-      }
-      return res(provider);
-    }, 100);
-  });
-}
-
-export {
-  metamaskClientsRdns,
-  getMetaMaskProviderEIP6963
-};
-//# sourceMappingURL=chunk-5XSXZTED.mjs.map

package/dist/chunk-5XSXZTED.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sdk/utils/eip-6963-metamask-provider.ts"],"sourcesContent":["import type { Eip1193Provider } from 'ethers';\n\n// We can isolate and create a metamask function/closure\nexport type AnnounceProviderEventDetail = {\n  info?: { rdns?: string };\n  provider?: Eip1193Provider;\n};\nexport type AnnounceProviderEvent = CustomEvent<AnnounceProviderEventDetail>;\n\nexport const metamaskClientsRdns = {\n  main: 'io.metamask',\n  flask: 'io.metamask.flask',\n  institutional: 'io.metamask.mmi',\n};\n\nexport type MetamaskClientRdnsKey = keyof typeof metamaskClientsRdns;\n\ntype MetaMaskClientType = 'any' | MetamaskClientRdnsKey;\n\n// Cache, as when the function is recalled, we can reuse instead of continue waiting\nconst providerCache: Partial<Record<MetaMaskClientType, Eip1193Provider>> = {};\n\n/**\n * This uses EIP6963 to find all metamask accounts and returns the first matching provider\n * the consumer requests (main, flask, institutional, or any)\n *\n * @param type - the MetaMask Wallet type (main, flask, institutional, or any)\n * @returns a ethers provider so you can make requests to that specific wallet\n */\nexport function getMetaMaskProviderEIP6963(\n  type: MetaMaskClientType = 'any',\n): Promise<Eip1193Provider | null> {\n  return new Promise<Eip1193Provider | null>((res) => {\n    if (type !== 'any' && metamaskClientsRdns[type] === undefined) {\n      res(null);\n      return;\n    }\n\n    const cachedProvider = providerCache[type];\n    if (cachedProvider) {\n      res(cachedProvider);\n      return;\n    }\n\n    const providers: { rdns: string; provider: Eip1193Provider }[] = [];\n\n    const handleProviderEvent = (event: unknown) => {\n      const typedEvent = event as CustomEvent<AnnounceProviderEventDetail>;\n      const providerDetail = typedEvent?.detail;\n      if (providerDetail?.provider && providerDetail?.info?.rdns) {\n        providers.push({\n          rdns: providerDetail?.info?.rdns,\n          provider: providerDetail?.provider,\n        });\n      }\n    };\n\n    window.addEventListener('eip6963:announceProvider', handleProviderEvent);\n    window.dispatchEvent(new Event('eip6963:requestProvider'));\n\n    /**\n     * It may take some time for the events to be emitted from the different wallets.\n     * So waiting a small period of time before we use the collected events.\n     */\n    setTimeout(() => {\n      // remove attached listener\n      window.removeEventListener(\n        'eip6963:announceProvider',\n        handleProviderEvent,\n      );\n\n      let provider: Eip1193Provider | null;\n      if (type === 'any') {\n        // return the first MM client we find\n        const metamaskClients = Object.values(metamaskClientsRdns);\n        provider =\n          providers.find((p) => metamaskClients.includes(p.rdns))?.provider ??\n          null;\n      } else {\n        const metamaskRdns = metamaskClientsRdns[type];\n        provider =\n          providers.find((p) => p.rdns === metamaskRdns)?.provider ?? null;\n      }\n\n      if (provider) {\n        providerCache[type] = provider;\n      }\n      return res(provider);\n    }, 100);\n  });\n}\n"],"mappings":";AASO,IAAM,sBAAsB;AAAA,EACjC,MAAM;AAAA,EACN,OAAO;AAAA,EACP,eAAe;AACjB;AAOA,IAAM,gBAAsE,CAAC;AAStE,SAAS,2BACd,OAA2B,OACM;AACjC,SAAO,IAAI,QAAgC,CAAC,QAAQ;AAClD,QAAI,SAAS,SAAS,oBAAoB,IAAI,MAAM,QAAW;AAC7D,UAAI,IAAI;AACR;AAAA,IACF;AAEA,UAAM,iBAAiB,cAAc,IAAI;AACzC,QAAI,gBAAgB;AAClB,UAAI,cAAc;AAClB;AAAA,IACF;AAEA,UAAM,YAA2D,CAAC;AAElE,UAAM,sBAAsB,CAAC,UAAmB;AAC9C,YAAM,aAAa;AACnB,YAAM,iBAAiB,YAAY;AACnC,UAAI,gBAAgB,YAAY,gBAAgB,MAAM,MAAM;AAC1D,kBAAU,KAAK;AAAA,UACb,MAAM,gBAAgB,MAAM;AAAA,UAC5B,UAAU,gBAAgB;AAAA,QAC5B,CAAC;AAAA,MACH;AAAA,IACF;AAEA,WAAO,iBAAiB,4BAA4B,mBAAmB;AACvE,WAAO,cAAc,IAAI,MAAM,yBAAyB,CAAC;AAMzD,eAAW,MAAM;AAEf,aAAO;AAAA,QACL;AAAA,QACA;AAAA,MACF;AAEA,UAAI;AACJ,UAAI,SAAS,OAAO;AAElB,cAAM,kBAAkB,OAAO,OAAO,mBAAmB;AACzD,mBACE,UAAU,KAAK,CAAC,MAAM,gBAAgB,SAAS,EAAE,IAAI,CAAC,GAAG,YACzD;AAAA,MACJ,OAAO;AACL,cAAM,eAAe,oBAAoB,IAAI;AAC7C,mBACE,UAAU,KAAK,CAAC,MAAM,EAAE,SAAS,YAAY,GAAG,YAAY;AAAA,MAChE;AAEA,UAAI,UAAU;AACZ,sBAAc,IAAI,IAAI;AAAA,MACxB;AACA,aAAO,IAAI,QAAQ;AAAA,IACrB,GAAG,GAAG;AAAA,EACR,CAAC;AACH;","names":[]}

package/dist/chunk-6DAK2U35.mjs

@@ -1,11 +0,0 @@
-import {
-  encryption_default
-} from "./chunk-COBJUBZE.mjs";
-
-// src/sdk/encryption.ts
-var encryption_default2 = encryption_default;
-
-export {
-  encryption_default2 as encryption_default
-};
-//# sourceMappingURL=chunk-6DAK2U35.mjs.map

package/dist/chunk-6DAK2U35.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sdk/encryption.ts"],"sourcesContent":["import encryption from '../controllers/user-storage/encryption/encryption';\n\nexport * from '../controllers/user-storage/encryption/encryption';\nexport default encryption;\n"],"mappings":";;;;;AAGA,IAAOA,sBAAQ;","names":["encryption_default"]}

package/dist/chunk-76NMME23.mjs

@@ -1,114 +0,0 @@
-import {
-  createEntryPath
-} from "./chunk-2VEMA6OE.mjs";
-import {
-  encryption_default
-} from "./chunk-KHASG4H3.mjs";
-import {
-  getEnvUrls
-} from "./chunk-KTCSRECK.mjs";
-
-// src/controllers/user-storage/services.ts
-import log from "loglevel";
-var ENV_URLS = getEnvUrls("prd" /* PRD */);
-var USER_STORAGE_API = ENV_URLS.userStorageApiUrl;
-var USER_STORAGE_ENDPOINT = `${USER_STORAGE_API}/api/v1/userstorage`;
-async function getUserStorage(opts) {
-  try {
-    const { bearerToken, path, storageKey, nativeScryptCrypto } = opts;
-    const encryptedPath = createEntryPath(path, storageKey);
-    const url = new URL(`${USER_STORAGE_ENDPOINT}${encryptedPath}`);
-    const userStorageResponse = await fetch(url.toString(), {
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${bearerToken}`
-      }
-    });
-    if (userStorageResponse.status === 404) {
-      return null;
-    }
-    if (userStorageResponse.status !== 200) {
-      throw new Error("Unable to get User Storage");
-    }
-    const userStorage = await userStorageResponse.json();
-    const encryptedData = userStorage?.Data ?? null;
-    if (!encryptedData) {
-      return null;
-    }
-    const decryptedData = await encryption_default.decryptString(
-      encryptedData,
-      opts.storageKey,
-      nativeScryptCrypto
-    );
-    return decryptedData;
-  } catch (e) {
-    log.error("Failed to get user storage", e);
-    return null;
-  }
-}
-async function getUserStorageAllFeatureEntries(opts) {
-  try {
-    const { bearerToken, path, nativeScryptCrypto } = opts;
-    const url = new URL(`${USER_STORAGE_ENDPOINT}/${path}`);
-    const userStorageResponse = await fetch(url.toString(), {
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${bearerToken}`
-      }
-    });
-    if (userStorageResponse.status === 404) {
-      return null;
-    }
-    if (userStorageResponse.status !== 200) {
-      throw new Error("Unable to get User Storage");
-    }
-    const userStorage = await userStorageResponse.json();
-    if (!Array.isArray(userStorage)) {
-      return null;
-    }
-    const decryptedData = userStorage?.flatMap((entry) => {
-      if (!entry.Data) {
-        return [];
-      }
-      return encryption_default.decryptString(
-        entry.Data,
-        opts.storageKey,
-        nativeScryptCrypto
-      );
-    });
-    return (await Promise.allSettled(decryptedData)).map((d) => d.status === "fulfilled" ? d.value : void 0).filter((d) => d !== void 0);
-  } catch (e) {
-    log.error("Failed to get user storage", e);
-    return null;
-  }
-}
-async function upsertUserStorage(data, opts) {
-  const { bearerToken, path, storageKey, nativeScryptCrypto } = opts;
-  const encryptedData = await encryption_default.encryptString(
-    data,
-    opts.storageKey,
-    nativeScryptCrypto
-  );
-  const encryptedPath = createEntryPath(path, storageKey);
-  const url = new URL(`${USER_STORAGE_ENDPOINT}${encryptedPath}`);
-  const res = await fetch(url.toString(), {
-    method: "PUT",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${bearerToken}`
-    },
-    body: JSON.stringify({ data: encryptedData })
-  });
-  if (!res.ok) {
-    throw new Error("user-storage - unable to upsert data");
-  }
-}
-
-export {
-  USER_STORAGE_API,
-  USER_STORAGE_ENDPOINT,
-  getUserStorage,
-  getUserStorageAllFeatureEntries,
-  upsertUserStorage
-};
-//# sourceMappingURL=chunk-76NMME23.mjs.map

package/dist/chunk-76NMME23.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/controllers/user-storage/services.ts"],"sourcesContent":["import log from 'loglevel';\n\nimport { Env, getEnvUrls } from '../../sdk/env';\nimport encryption from './encryption';\nimport type {\n  UserStoragePathWithFeatureAndKey,\n  UserStoragePathWithFeatureOnly,\n} from './schema';\nimport { createEntryPath } from './schema';\nimport type { NativeScrypt } from './UserStorageController';\n\nconst ENV_URLS = getEnvUrls(Env.PRD);\n\nexport const USER_STORAGE_API: string = ENV_URLS.userStorageApiUrl;\nexport const USER_STORAGE_ENDPOINT = `${USER_STORAGE_API}/api/v1/userstorage`;\n\n/**\n * This is the Server Response shape for a feature entry.\n */\nexport type GetUserStorageResponse = {\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  HashedKey: string;\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  Data: string;\n};\n\nexport type GetUserStorageAllFeatureEntriesResponse = {\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  HashedKey: string;\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  Data: string;\n}[];\n\nexport type UserStorageBaseOptions = {\n  bearerToken: string;\n  storageKey: string;\n};\n\nexport type UserStorageOptions = UserStorageBaseOptions & {\n  path: UserStoragePathWithFeatureAndKey;\n  nativeScryptCrypto?: NativeScrypt;\n};\n\nexport type UserStorageAllFeatureEntriesOptions = UserStorageBaseOptions & {\n  path: UserStoragePathWithFeatureOnly;\n  nativeScryptCrypto?: NativeScrypt;\n};\n\n/**\n * User Storage Service - Get Storage Entry.\n *\n * @param opts - User Storage Options\n * @returns The storage entry, or null if fails to find entry\n */\nexport async function getUserStorage(\n  opts: UserStorageOptions,\n): Promise<string | null> {\n  try {\n    const { bearerToken, path, storageKey, nativeScryptCrypto } = opts;\n\n    const encryptedPath = createEntryPath(path, storageKey);\n    const url = new URL(`${USER_STORAGE_ENDPOINT}${encryptedPath}`);\n\n    const userStorageResponse = await fetch(url.toString(), {\n      headers: {\n        'Content-Type': 'application/json',\n        Authorization: `Bearer ${bearerToken}`,\n      },\n    });\n\n    // Acceptable error - since indicates entry does not exist.\n    if (userStorageResponse.status === 404) {\n      return null;\n    }\n\n    if (userStorageResponse.status !== 200) {\n      throw new Error('Unable to get User Storage');\n    }\n\n    const userStorage: GetUserStorageResponse | null =\n      await userStorageResponse.json();\n    const encryptedData = userStorage?.Data ?? null;\n\n    if (!encryptedData) {\n      return null;\n    }\n\n    const decryptedData = await encryption.decryptString(\n      encryptedData,\n      opts.storageKey,\n      nativeScryptCrypto,\n    );\n\n    return decryptedData;\n  } catch (e) {\n    log.error('Failed to get user storage', e);\n    return null;\n  }\n}\n\n/**\n * User Storage Service - Get all storage entries for a specific feature.\n *\n * @param opts - User Storage Options\n * @returns The storage entry, or null if fails to find entry\n */\nexport async function getUserStorageAllFeatureEntries(\n  opts: UserStorageAllFeatureEntriesOptions,\n): Promise<string[] | null> {\n  try {\n    const { bearerToken, path, nativeScryptCrypto } = opts;\n    const url = new URL(`${USER_STORAGE_ENDPOINT}/${path}`);\n\n    const userStorageResponse = await fetch(url.toString(), {\n      headers: {\n        'Content-Type': 'application/json',\n        Authorization: `Bearer ${bearerToken}`,\n      },\n    });\n\n    // Acceptable error - since indicates feature does not exist.\n    if (userStorageResponse.status === 404) {\n      return null;\n    }\n\n    if (userStorageResponse.status !== 200) {\n      throw new Error('Unable to get User Storage');\n    }\n\n    const userStorage: GetUserStorageAllFeatureEntriesResponse | null =\n      await userStorageResponse.json();\n\n    if (!Array.isArray(userStorage)) {\n      return null;\n    }\n\n    const decryptedData = userStorage?.flatMap((entry) => {\n      if (!entry.Data) {\n        return [];\n      }\n\n      return encryption.decryptString(\n        entry.Data,\n        opts.storageKey,\n        nativeScryptCrypto,\n      );\n    });\n\n    return (await Promise.allSettled(decryptedData))\n      .map((d) => (d.status === 'fulfilled' ? d.value : undefined))\n      .filter((d): d is string => d !== undefined);\n  } catch (e) {\n    log.error('Failed to get user storage', e);\n    return null;\n  }\n}\n\n/**\n * User Storage Service - Set Storage Entry.\n *\n * @param data - data to store\n * @param opts - storage options\n */\nexport async function upsertUserStorage(\n  data: string,\n  opts: UserStorageOptions,\n): Promise<void> {\n  const { bearerToken, path, storageKey, nativeScryptCrypto } = opts;\n\n  const encryptedData = await encryption.encryptString(\n    data,\n    opts.storageKey,\n    nativeScryptCrypto,\n  );\n  const encryptedPath = createEntryPath(path, storageKey);\n  const url = new URL(`${USER_STORAGE_ENDPOINT}${encryptedPath}`);\n\n  const res = await fetch(url.toString(), {\n    method: 'PUT',\n    headers: {\n      'Content-Type': 'application/json',\n      Authorization: `Bearer ${bearerToken}`,\n    },\n    body: JSON.stringify({ data: encryptedData }),\n  });\n\n  if (!res.ok) {\n    throw new Error('user-storage - unable to upsert data');\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-76VRE4BI.mjs

@@ -1,18 +0,0 @@
-// src/controllers/user-storage/encryption/utils.ts
-var byteArrayToBase64 = (byteArray) => {
-  return Buffer.from(byteArray).toString("base64");
-};
-var base64ToByteArray = (base64) => {
-  return new Uint8Array(Buffer.from(base64, "base64"));
-};
-var bytesToUtf8 = (byteArray) => {
-  const decoder = new TextDecoder("utf-8");
-  return decoder.decode(byteArray);
-};
-
-export {
-  byteArrayToBase64,
-  base64ToByteArray,
-  bytesToUtf8
-};
-//# sourceMappingURL=chunk-76VRE4BI.mjs.map

package/dist/chunk-76VRE4BI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/controllers/user-storage/encryption/utils.ts"],"sourcesContent":["export const byteArrayToBase64 = (byteArray: Uint8Array) => {\n  return Buffer.from(byteArray).toString('base64');\n};\n\nexport const base64ToByteArray = (base64: string) => {\n  return new Uint8Array(Buffer.from(base64, 'base64'));\n};\n\nexport const bytesToUtf8 = (byteArray: Uint8Array) => {\n  const decoder = new TextDecoder('utf-8');\n  return decoder.decode(byteArray);\n};\n"],"mappings":";AAAO,IAAM,oBAAoB,CAAC,cAA0B;AAC1D,SAAO,OAAO,KAAK,SAAS,EAAE,SAAS,QAAQ;AACjD;AAEO,IAAM,oBAAoB,CAAC,WAAmB;AACnD,SAAO,IAAI,WAAW,OAAO,KAAK,QAAQ,QAAQ,CAAC;AACrD;AAEO,IAAM,cAAc,CAAC,cAA0B;AACpD,QAAM,UAAU,IAAI,YAAY,OAAO;AACvC,SAAO,QAAQ,OAAO,SAAS;AACjC;","names":[]}

package/dist/chunk-7MSQV43P.mjs

@@ -1,77 +0,0 @@
-import {
-  JwtBearerAuth
-} from "./chunk-YKOMKXG4.mjs";
-import {
-  SIWEJwtBearerAuth
-} from "./chunk-2CWF7ZTL.mjs";
-import {
-  SRPJwtBearerAuth
-} from "./chunk-J7NSK6BO.mjs";
-import {
-  AuthType
-} from "./chunk-CAIIVJAO.mjs";
-import {
-  MESSAGE_SIGNING_SNAP,
-  SNAP_ORIGIN,
-  connectSnap,
-  getSnap,
-  getSnaps
-} from "./chunk-5EBUFNAN.mjs";
-import {
-  STORAGE_URL,
-  UserStorage
-} from "./chunk-MK7ABX2V.mjs";
-import {
-  createSHA256Hash
-} from "./chunk-COBJUBZE.mjs";
-import {
-  Env,
-  Platform,
-  getEnvUrls,
-  getOidcClientId
-} from "./chunk-KTCSRECK.mjs";
-import {
-  NonceRetrievalError,
-  NotFoundError,
-  PairError,
-  SignInError,
-  UnsupportedAuthTypeError,
-  UserStorageError,
-  ValidationError
-} from "./chunk-TFFQFIJV.mjs";
-import {
-  __export
-} from "./chunk-U5UIDVOO.mjs";
-
-// src/sdk/index.ts
-var sdk_exports = {};
-__export(sdk_exports, {
-  AuthType: () => AuthType,
-  Env: () => Env,
-  JwtBearerAuth: () => JwtBearerAuth,
-  MESSAGE_SIGNING_SNAP: () => MESSAGE_SIGNING_SNAP,
-  NonceRetrievalError: () => NonceRetrievalError,
-  NotFoundError: () => NotFoundError,
-  PairError: () => PairError,
-  Platform: () => Platform,
-  SIWEJwtBearerAuth: () => SIWEJwtBearerAuth,
-  SNAP_ORIGIN: () => SNAP_ORIGIN,
-  SRPJwtBearerAuth: () => SRPJwtBearerAuth,
-  STORAGE_URL: () => STORAGE_URL,
-  SignInError: () => SignInError,
-  UnsupportedAuthTypeError: () => UnsupportedAuthTypeError,
-  UserStorage: () => UserStorage,
-  UserStorageError: () => UserStorageError,
-  ValidationError: () => ValidationError,
-  connectSnap: () => connectSnap,
-  createSHA256Hash: () => createSHA256Hash,
-  getEnvUrls: () => getEnvUrls,
-  getOidcClientId: () => getOidcClientId,
-  getSnap: () => getSnap,
-  getSnaps: () => getSnaps
-});
-
-export {
-  sdk_exports
-};
-//# sourceMappingURL=chunk-7MSQV43P.mjs.map

package/dist/chunk-7MSQV43P.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sdk/index.ts"],"sourcesContent":["export * from './authentication';\nexport * from './user-storage';\nexport * from './env';\nexport * from './errors';\nexport * from './encryption';\nexport * from './utils/messaging-signing-snap-requests';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;","names":[]}

package/dist/chunk-BKQE7DB5.js

@@ -1,170 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-var _chunkUAXWZN5Jjs = require('./chunk-UAXWZN5J.js');
-
-
-
-
-var _chunkPCOIRDTOjs = require('./chunk-PCOIRDTO.js');
-
-
-
-var _chunkIGY2S5BCjs = require('./chunk-IGY2S5BC.js');
-
-// src/controllers/user-storage/encryption/encryption.ts
-var _aes = require('@noble/ciphers/aes');
-var _webcrypto = require('@noble/ciphers/webcrypto');
-var _scrypt = require('@noble/hashes/scrypt');
-var _sha256 = require('@noble/hashes/sha256');
-var _utils = require('@noble/hashes/utils');
-var ALGORITHM_NONCE_SIZE = 12;
-var ALGORITHM_KEY_SIZE = 16;
-var SCRYPT_SALT_SIZE = 16;
-var SCRYPT_N = 2 ** 17;
-var SCRYPT_r = 8;
-var SCRYPT_p = 1;
-var _encryptStringV1, encryptStringV1_fn, _decryptStringV1, decryptStringV1_fn, _encrypt, encrypt_fn, _decrypt, decrypt_fn, _getOrGenerateScryptKey, getOrGenerateScryptKey_fn;
-var EncryptorDecryptor = class {
-  constructor() {
-    _chunkIGY2S5BCjs.__privateAdd.call(void 0, this, _encryptStringV1);
-    _chunkIGY2S5BCjs.__privateAdd.call(void 0, this, _decryptStringV1);
-    _chunkIGY2S5BCjs.__privateAdd.call(void 0, this, _encrypt);
-    _chunkIGY2S5BCjs.__privateAdd.call(void 0, this, _decrypt);
-    _chunkIGY2S5BCjs.__privateAdd.call(void 0, this, _getOrGenerateScryptKey);
-  }
-  async encryptString(plaintext, password, nativeScryptCrypto) {
-    try {
-      return await _chunkIGY2S5BCjs.__privateMethod.call(void 0, this, _encryptStringV1, encryptStringV1_fn).call(this, plaintext, password, nativeScryptCrypto);
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
-      throw new Error(`Unable to encrypt string - ${errorMessage}`);
-    }
-  }
-  async decryptString(encryptedDataStr, password, nativeScryptCrypto) {
-    try {
-      const encryptedData = JSON.parse(encryptedDataStr);
-      if (encryptedData.v === "1") {
-        if (encryptedData.t === "scrypt") {
-          return await _chunkIGY2S5BCjs.__privateMethod.call(void 0, this, _decryptStringV1, decryptStringV1_fn).call(this, encryptedData, password, nativeScryptCrypto);
-        }
-      }
-      throw new Error(
-        `Unsupported encrypted data payload - ${encryptedDataStr}`
-      );
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
-      throw new Error(`Unable to decrypt string - ${errorMessage}`);
-    }
-  }
-};
-_encryptStringV1 = new WeakSet();
-encryptStringV1_fn = async function(plaintext, password, nativeScryptCrypto) {
-  const { key, salt } = await _chunkIGY2S5BCjs.__privateMethod.call(void 0, this, _getOrGenerateScryptKey, getOrGenerateScryptKey_fn).call(this, password, {
-    N: SCRYPT_N,
-    r: SCRYPT_r,
-    p: SCRYPT_p,
-    dkLen: ALGORITHM_KEY_SIZE
-  }, _webcrypto.randomBytes.call(void 0, SCRYPT_SALT_SIZE), nativeScryptCrypto);
-  const plaintextRaw = _utils.utf8ToBytes.call(void 0, plaintext);
-  const ciphertextAndNonceAndSalt = _utils.concatBytes.call(void 0, 
-    salt,
-    _chunkIGY2S5BCjs.__privateMethod.call(void 0, this, _encrypt, encrypt_fn).call(this, plaintextRaw, key)
-  );
-  const encryptedData = _chunkPCOIRDTOjs.byteArrayToBase64.call(void 0, ciphertextAndNonceAndSalt);
-  const encryptedPayload = {
-    v: "1",
-    t: "scrypt",
-    d: encryptedData,
-    o: {
-      N: SCRYPT_N,
-      r: SCRYPT_r,
-      p: SCRYPT_p,
-      dkLen: ALGORITHM_KEY_SIZE
-    },
-    saltLen: SCRYPT_SALT_SIZE
-  };
-  return JSON.stringify(encryptedPayload);
-};
-_decryptStringV1 = new WeakSet();
-decryptStringV1_fn = async function(data, password, nativeScryptCrypto) {
-  const { o, d: base64CiphertextAndNonceAndSalt, saltLen } = data;
-  const ciphertextAndNonceAndSalt = _chunkPCOIRDTOjs.base64ToByteArray.call(void 0, 
-    base64CiphertextAndNonceAndSalt
-  );
-  const salt = ciphertextAndNonceAndSalt.slice(0, saltLen);
-  const ciphertextAndNonce = ciphertextAndNonceAndSalt.slice(
-    saltLen,
-    ciphertextAndNonceAndSalt.length
-  );
-  const { key } = await _chunkIGY2S5BCjs.__privateMethod.call(void 0, this, _getOrGenerateScryptKey, getOrGenerateScryptKey_fn).call(this, password, {
-    N: o.N,
-    r: o.r,
-    p: o.p,
-    dkLen: o.dkLen
-  }, salt, nativeScryptCrypto);
-  return _chunkPCOIRDTOjs.bytesToUtf8.call(void 0, _chunkIGY2S5BCjs.__privateMethod.call(void 0, this, _decrypt, decrypt_fn).call(this, ciphertextAndNonce, key));
-};
-_encrypt = new WeakSet();
-encrypt_fn = function(plaintext, key) {
-  const nonce = _webcrypto.randomBytes.call(void 0, ALGORITHM_NONCE_SIZE);
-  const ciphertext = _aes.gcm.call(void 0, key, nonce).encrypt(plaintext);
-  return _utils.concatBytes.call(void 0, nonce, ciphertext);
-};
-_decrypt = new WeakSet();
-decrypt_fn = function(ciphertextAndNonce, key) {
-  const nonce = ciphertextAndNonce.slice(0, ALGORITHM_NONCE_SIZE);
-  const ciphertext = ciphertextAndNonce.slice(
-    ALGORITHM_NONCE_SIZE,
-    ciphertextAndNonce.length
-  );
-  return _aes.gcm.call(void 0, key, nonce).decrypt(ciphertext);
-};
-_getOrGenerateScryptKey = new WeakSet();
-getOrGenerateScryptKey_fn = async function(password, o, salt, nativeScryptCrypto) {
-  const hashedPassword = createSHA256Hash(password);
-  const cachedKey = salt ? _chunkUAXWZN5Jjs.getCachedKeyBySalt.call(void 0, hashedPassword, salt) : _chunkUAXWZN5Jjs.getAnyCachedKey.call(void 0, hashedPassword);
-  if (cachedKey) {
-    return {
-      key: cachedKey.key,
-      salt: cachedKey.salt
-    };
-  }
-  const newSalt = salt ?? _webcrypto.randomBytes.call(void 0, SCRYPT_SALT_SIZE);
-  let newKey;
-  if (nativeScryptCrypto) {
-    newKey = await nativeScryptCrypto(
-      password,
-      newSalt,
-      o.N,
-      o.r,
-      o.p,
-      o.dkLen
-    );
-  } else {
-    newKey = await _scrypt.scryptAsync.call(void 0, password, newSalt, {
-      N: o.N,
-      r: o.r,
-      p: o.p,
-      dkLen: o.dkLen
-    });
-  }
-  _chunkUAXWZN5Jjs.setCachedKey.call(void 0, hashedPassword, newSalt, newKey);
-  return {
-    key: newKey,
-    salt: newSalt
-  };
-};
-var encryption = new EncryptorDecryptor();
-var encryption_default = encryption;
-function createSHA256Hash(data) {
-  const hashedData = _sha256.sha256.call(void 0, data);
-  return _utils.bytesToHex.call(void 0, hashedData);
-}
-
-
-
-
-exports.encryption_default = encryption_default; exports.createSHA256Hash = createSHA256Hash;
-//# sourceMappingURL=chunk-BKQE7DB5.js.map

package/dist/chunk-BKQE7DB5.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/controllers/user-storage/encryption/encryption.ts"],"names":[],"mappings":"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","sourcesContent":["import { gcm } from '@noble/ciphers/aes';\nimport { randomBytes } from '@noble/ciphers/webcrypto';\nimport { scryptAsync } from '@noble/hashes/scrypt';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { utf8ToBytes, concatBytes, bytesToHex } from '@noble/hashes/utils';\n\nimport type { NativeScrypt } from '../UserStorageController';\nimport { getAnyCachedKey, getCachedKeyBySalt, setCachedKey } from './cache';\nimport { base64ToByteArray, byteArrayToBase64, bytesToUtf8 } from './utils';\n\nexport type EncryptedPayload = {\n  // version\n  v: '1';\n\n  // key derivation function algorithm - scrypt\n  t: 'scrypt';\n\n  // data\n  d: string;\n\n  // encryption options - scrypt\n  o: {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    N: number;\n    r: number;\n    p: number;\n    dkLen: number;\n  };\n\n  // Salt options\n  saltLen: number;\n};\n\n// Nonce/Key Sizes\nconst ALGORITHM_NONCE_SIZE = 12; // 12 bytes\nconst ALGORITHM_KEY_SIZE = 16; // 16 bytes\n\n// Scrypt settings\n// see: https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html#scrypt\nconst SCRYPT_SALT_SIZE = 16; // 16 bytes\nconst SCRYPT_N = 2 ** 17; // CPU/memory cost parameter (must be a power of 2, > 1)\n// eslint-disable-next-line @typescript-eslint/naming-convention\nconst SCRYPT_r = 8; // Block size parameter\n// eslint-disable-next-line @typescript-eslint/naming-convention\nconst SCRYPT_p = 1; // Parallelization parameter\n\nclass EncryptorDecryptor {\n  async encryptString(\n    plaintext: string,\n    password: string,\n    nativeScryptCrypto?: NativeScrypt,\n  ): Promise<string> {\n    try {\n      return await this.#encryptStringV1(\n        plaintext,\n        password,\n        nativeScryptCrypto,\n      );\n    } catch (e) {\n      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);\n      throw new Error(`Unable to encrypt string - ${errorMessage}`);\n    }\n  }\n\n  async decryptString(\n    encryptedDataStr: string,\n    password: string,\n    nativeScryptCrypto?: NativeScrypt,\n  ): Promise<string> {\n    try {\n      const encryptedData: EncryptedPayload = JSON.parse(encryptedDataStr);\n      if (encryptedData.v === '1') {\n        if (encryptedData.t === 'scrypt') {\n          return await this.#decryptStringV1(\n            encryptedData,\n            password,\n            nativeScryptCrypto,\n          );\n        }\n      }\n      throw new Error(\n        `Unsupported encrypted data payload - ${encryptedDataStr}`,\n      );\n    } catch (e) {\n      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);\n      throw new Error(`Unable to decrypt string - ${errorMessage}`);\n    }\n  }\n\n  async #encryptStringV1(\n    plaintext: string,\n    password: string,\n    nativeScryptCrypto?: NativeScrypt,\n  ): Promise<string> {\n    const { key, salt } = await this.#getOrGenerateScryptKey(\n      password,\n      {\n        N: SCRYPT_N,\n        r: SCRYPT_r,\n        p: SCRYPT_p,\n        dkLen: ALGORITHM_KEY_SIZE,\n      },\n      randomBytes(SCRYPT_SALT_SIZE),\n      nativeScryptCrypto,\n    );\n\n    // Encrypt and prepend salt.\n    const plaintextRaw = utf8ToBytes(plaintext);\n    const ciphertextAndNonceAndSalt = concatBytes(\n      salt,\n      this.#encrypt(plaintextRaw, key),\n    );\n\n    // Convert to Base64\n    const encryptedData = byteArrayToBase64(ciphertextAndNonceAndSalt);\n\n    const encryptedPayload: EncryptedPayload = {\n      v: '1',\n      t: 'scrypt',\n      d: encryptedData,\n      o: {\n        N: SCRYPT_N,\n        r: SCRYPT_r,\n        p: SCRYPT_p,\n        dkLen: ALGORITHM_KEY_SIZE,\n      },\n      saltLen: SCRYPT_SALT_SIZE,\n    };\n\n    return JSON.stringify(encryptedPayload);\n  }\n\n  async #decryptStringV1(\n    data: EncryptedPayload,\n    password: string,\n    nativeScryptCrypto?: NativeScrypt,\n  ): Promise<string> {\n    const { o, d: base64CiphertextAndNonceAndSalt, saltLen } = data;\n\n    // Decode the base64.\n    const ciphertextAndNonceAndSalt = base64ToByteArray(\n      base64CiphertextAndNonceAndSalt,\n    );\n\n    // Create buffers of salt and ciphertextAndNonce.\n    const salt = ciphertextAndNonceAndSalt.slice(0, saltLen);\n    const ciphertextAndNonce = ciphertextAndNonceAndSalt.slice(\n      saltLen,\n      ciphertextAndNonceAndSalt.length,\n    );\n\n    // Derive the key.\n    const { key } = await this.#getOrGenerateScryptKey(\n      password,\n      {\n        N: o.N,\n        r: o.r,\n        p: o.p,\n        dkLen: o.dkLen,\n      },\n      salt,\n      nativeScryptCrypto,\n    );\n\n    // Decrypt and return result.\n    return bytesToUtf8(this.#decrypt(ciphertextAndNonce, key));\n  }\n\n  #encrypt(plaintext: Uint8Array, key: Uint8Array): Uint8Array {\n    const nonce = randomBytes(ALGORITHM_NONCE_SIZE);\n\n    // Encrypt and prepend nonce.\n    const ciphertext = gcm(key, nonce).encrypt(plaintext);\n\n    return concatBytes(nonce, ciphertext);\n  }\n\n  #decrypt(ciphertextAndNonce: Uint8Array, key: Uint8Array): Uint8Array {\n    // Create buffers of nonce and ciphertext.\n    const nonce = ciphertextAndNonce.slice(0, ALGORITHM_NONCE_SIZE);\n    const ciphertext = ciphertextAndNonce.slice(\n      ALGORITHM_NONCE_SIZE,\n      ciphertextAndNonce.length,\n    );\n\n    // Decrypt and return result.\n    return gcm(key, nonce).decrypt(ciphertext);\n  }\n\n  async #getOrGenerateScryptKey(\n    password: string,\n    o: EncryptedPayload['o'],\n    salt?: Uint8Array,\n    nativeScryptCrypto?: NativeScrypt,\n  ) {\n    const hashedPassword = createSHA256Hash(password);\n    const cachedKey = salt\n      ? getCachedKeyBySalt(hashedPassword, salt)\n      : getAnyCachedKey(hashedPassword);\n\n    if (cachedKey) {\n      return {\n        key: cachedKey.key,\n        salt: cachedKey.salt,\n      };\n    }\n\n    const newSalt = salt ?? randomBytes(SCRYPT_SALT_SIZE);\n\n    let newKey: Uint8Array;\n\n    if (nativeScryptCrypto) {\n      newKey = await nativeScryptCrypto(\n        password,\n        newSalt,\n        o.N,\n        o.r,\n        o.p,\n        o.dkLen,\n      );\n    } else {\n      newKey = await scryptAsync(password, newSalt, {\n        N: o.N,\n        r: o.r,\n        p: o.p,\n        dkLen: o.dkLen,\n      });\n    }\n    setCachedKey(hashedPassword, newSalt, newKey);\n\n    return {\n      key: newKey,\n      salt: newSalt,\n    };\n  }\n}\n\nconst encryption = new EncryptorDecryptor();\nexport default encryption;\n\n/**\n * Receive a SHA256 hash from a given string\n * @param data - input\n * @returns sha256 hash\n */\nexport function createSHA256Hash(data: string): string {\n  const hashedData = sha256(data);\n  return bytesToHex(hashedData);\n}\n"]}

package/dist/chunk-CAIIVJAO.mjs

@@ -1,11 +0,0 @@
-// src/sdk/authentication-jwt-bearer/types.ts
-var AuthType = /* @__PURE__ */ ((AuthType2) => {
-  AuthType2["SRP"] = "SRP";
-  AuthType2["SiWE"] = "SiWE";
-  return AuthType2;
-})(AuthType || {});
-
-export {
-  AuthType
-};
-//# sourceMappingURL=chunk-CAIIVJAO.mjs.map

package/dist/chunk-CAIIVJAO.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sdk/authentication-jwt-bearer/types.ts"],"sourcesContent":["import type { Env, Platform } from '../env';\n\nexport enum AuthType {\n  /* sign in using a private key derived from your secret recovery phrase (SRP). \n       Uses message signing snap to perform this operation */\n  SRP = 'SRP',\n\n  /* sign in with Ethereum */\n  SiWE = 'SiWE',\n}\n\nexport type AuthConfig = {\n  env: Env;\n  platform: Platform;\n  type: AuthType;\n};\n\nexport type AccessToken = {\n  /**\n   * The JWT Access Token\n   */\n  accessToken: string;\n  /**\n   * Expiration in seconds\n   */\n  expiresIn: number;\n  /**\n   * Date in milliseconds\n   */\n  obtainedAt: number;\n};\n\nexport type UserProfile = {\n  /**\n   * The \"Identifier\" used to log in with.\n   */\n  identifierId: string;\n  /**\n   * The Unique profile for a logged in user. A Profile can be logged in via multiple Identifiers\n   */\n  profileId: string;\n  /**\n   * Server MetaMetrics ID. Allows grouping of user events cross platform.\n   */\n  metaMetricsId: string;\n};\n\nexport type LoginResponse = {\n  token: AccessToken;\n  profile: UserProfile;\n};\n\nexport type IBaseAuth = {\n  getAccessToken: () => Promise<string>;\n  getUserProfile: () => Promise<UserProfile>;\n  getIdentifier: () => Promise<string>;\n  signMessage: (message: string) => Promise<string>;\n};\n\nexport type AuthStorageOptions = {\n  getLoginResponse: () => Promise<LoginResponse | null>;\n  setLoginResponse: (val: LoginResponse) => Promise<void>;\n};\n\nexport type AuthSigningOptions = {\n  signMessage: (message: string) => Promise<string>;\n  getIdentifier: () => Promise<string>;\n};\n\nexport type ErrorMessage = {\n  message: string;\n  error: string;\n};\n\nexport type Pair = {\n  identifier: string;\n  encryptedStorageKey: string;\n  identifierType: 'SIWE' | 'SRP';\n  signMessage: (message: string) => Promise<string>;\n};\n"],"mappings":";AAEO,IAAK,WAAL,kBAAKA,cAAL;AAGL,EAAAA,UAAA,SAAM;AAGN,EAAAA,UAAA,UAAO;AANG,SAAAA;AAAA,GAAA;","names":["AuthType"]}