@metamask/snaps-rpc-methods 6.0.0 → 7.0.0

package/dist/esm/restricted/getEntropy.js

@@ -1,58 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SIP_6_MAGIC_VALUE } from '@metamask/snaps-utils';
-import { assertStruct } from '@metamask/utils';
-import { literal, object, optional, string } from 'superstruct';
-import { deriveEntropy } from '../utils';
-const targetName = 'snap_getEntropy';
-export const GetEntropyArgsStruct = object({
-    version: literal(1),
-    salt: optional(string())
-});
-const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats,
-        methodImplementation: getEntropyImplementation(methodHooks),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-export const getEntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getEntropy`. The implementation
- * is based on the reference implementation of
- * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.getMnemonic - The method to get the mnemonic of the user's
- * primary keyring.
- * @param hooks.getUnlockPromise - The method to get a promise that resolves
- * once the extension is unlocked.
- * @returns The method implementation.
- */ function getEntropyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getEntropy(options) {
-        const { params, context: { origin } } = options;
-        assertStruct(params, GetEntropyArgsStruct, 'Invalid "snap_getEntropy" parameters', rpcErrors.invalidParams);
-        await getUnlockPromise(true);
-        const mnemonicPhrase = await getMnemonic();
-        return deriveEntropy({
-            input: origin,
-            salt: params.salt,
-            mnemonicPhrase,
-            magic: SIP_6_MAGIC_VALUE
-        });
-    };
-}
-
-//# sourceMappingURL=getEntropy.js.map

package/dist/esm/restricted/getEntropy.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/getEntropy.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { GetEntropyParams, GetEntropyResult } from '@metamask/snaps-sdk';\nimport { SIP_6_MAGIC_VALUE } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport type { Infer } from 'superstruct';\nimport { literal, object, optional, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\nconst targetName = 'snap_getEntropy';\n\ntype GetEntropySpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: GetEntropyHooks;\n};\n\ntype GetEntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getEntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\nexport const GetEntropyArgsStruct = object({\n  version: literal(1),\n  salt: optional(string()),\n});\n\n/**\n * @property version - The version of the `snap_getEntropy` method. This must be\n * the numeric literal `1`.\n * @property salt - A string to use as the salt when deriving the entropy. If\n * omitted, the salt will be an empty string.\n */\nexport type GetEntropyArgs = Infer<typeof GetEntropyArgsStruct>;\n\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetEntropySpecificationBuilderOptions,\n  GetEntropySpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: GetEntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats,\n    methodImplementation: getEntropyImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetEntropyHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getEntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport type GetEntropyHooks = {\n  /**\n   * @returns The mnemonic of the user's primary keyring.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * Waits for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n};\n\n/**\n * Builds the method implementation for `snap_getEntropy`. The implementation\n * is based on the reference implementation of\n * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - The method to get the mnemonic of the user's\n * primary keyring.\n * @param hooks.getUnlockPromise - The method to get a promise that resolves\n * once the extension is unlocked.\n * @returns The method implementation.\n */\nfunction getEntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetEntropyHooks) {\n  return async function getEntropy(\n    options: RestrictedMethodOptions<GetEntropyParams>,\n  ): Promise<GetEntropyResult> {\n    const {\n      params,\n      context: { origin },\n    } = options;\n\n    assertStruct(\n      params,\n      GetEntropyArgsStruct,\n      'Invalid \"snap_getEntropy\" parameters',\n      rpcErrors.invalidParams,\n    );\n\n    await getUnlockPromise(true);\n    const mnemonicPhrase = await getMnemonic();\n\n    return deriveEntropy({\n      input: origin,\n      salt: params.salt,\n      mnemonicPhrase,\n      magic: SIP_6_MAGIC_VALUE,\n    });\n  };\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","SIP_6_MAGIC_VALUE","assertStruct","literal","object","optional","string","deriveEntropy","targetName","GetEntropyArgsStruct","version","salt","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","methodImplementation","getEntropyImplementation","subjectTypes","Snap","getMnemonic","getUnlockPromise","getEntropyBuilder","Object","freeze","getEntropy","options","params","context","origin","invalidParams","mnemonicPhrase","input","magic"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAEjD,SAASC,iBAAiB,QAAQ,wBAAwB;AAE1D,SAASC,YAAY,QAAQ,kBAAkB;AAE/C,SAASC,OAAO,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,MAAM,QAAQ,cAAc;AAGhE,SAASC,aAAa,QAAQ,WAAW;AAEzC,MAAMC,aAAa;AAcnB,OAAO,MAAMC,uBAAuBL,OAAO;IACzCM,SAASP,QAAQ;IACjBQ,MAAMN,SAASC;AACjB,GAAG;AAUH,MAAMM,uBAIF,CAAC,EACHC,iBAAiB,IAAI,EACrBC,WAAW,EAC2B;IACtC,OAAO;QACLC,gBAAgBjB,eAAekB,gBAAgB;QAC/CR;QACAK;QACAI,sBAAsBC,yBAAyBJ;QAC/CK,cAAc;YAACpB,YAAYqB,IAAI;SAAC;IAClC;AACF;AAEA,MAAMN,cAAkD;IACtDO,aAAa;IACbC,kBAAkB;AACpB;AAEA,OAAO,MAAMC,oBAAoBC,OAAOC,MAAM,CAAC;IAC7CjB;IACAI;IACAE;AACF,GAAY;AAgBZ;;;;;;;;;;;CAWC,GACD,SAASI,yBAAyB,EAChCG,WAAW,EACXC,gBAAgB,EACA;IAChB,OAAO,eAAeI,WACpBC,OAAkD;QAElD,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGH;QAEJzB,aACE0B,QACAnB,sBACA,wCACAT,UAAU+B,aAAa;QAGzB,MAAMT,iBAAiB;QACvB,MAAMU,iBAAiB,MAAMX;QAE7B,OAAOd,cAAc;YACnB0B,OAAOH;YACPnB,MAAMiB,OAAOjB,IAAI;YACjBqB;YACAE,OAAOjC;QACT;IACF;AACF"}

package/dist/esm/restricted/getLocale.js

@@ -1,42 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-const methodName = 'snap_getLocale';
-/**
- * The specification builder for the `snap_getLocale` permission.
- * `snap_getLocale` allows snaps to get the user selected locale.
- *
- * @param options - The specification builder options.
- * @param options.allowedCaveats - The optional allowed caveats for the permission.
- * @param options.methodHooks - The RPC method hooks needed by the method implementation.
- * @returns The specification for the `snap_getLocale` permission.
- */ export const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: getImplementation(methodHooks),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getLocale: true
-};
-export const getLocaleBuilder = Object.freeze({
-    targetName: methodName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getLocale`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.getLocale - A function that returns the user selected locale.
- * @returns The user selected locale.
- */ export function getImplementation({ getLocale }) {
-    return async function implementation(_args) {
-        return getLocale();
-    };
-}
-
-//# sourceMappingURL=getLocale.js.map

package/dist/esm/restricted/getLocale.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/getLocale.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { GetLocaleResult } from '@metamask/snaps-sdk';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_getLocale';\n\nexport type GetLocaleMethodHooks = {\n  getLocale: () => Promise<string>;\n};\n\ntype SpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: GetLocaleMethodHooks;\n};\n\ntype Specification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_getLocale` permission.\n * `snap_getLocale` allows snaps to get the user selected locale.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_getLocale` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  SpecificationBuilderOptions,\n  Specification\n> = ({ allowedCaveats = null, methodHooks }: SpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetLocaleMethodHooks> = {\n  getLocale: true,\n};\n\nexport const getLocaleBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getLocale`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getLocale - A function that returns the user selected locale.\n * @returns The user selected locale.\n */\nexport function getImplementation({ getLocale }: GetLocaleMethodHooks) {\n  return async function implementation(\n    _args: RestrictedMethodOptions<RestrictedMethodParameters>,\n  ): Promise<GetLocaleResult> {\n    return getLocale();\n  };\n}\n"],"names":["PermissionType","SubjectType","methodName","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","getImplementation","subjectTypes","Snap","getLocale","getLocaleBuilder","Object","freeze","implementation","_args"],"mappings":"AAMA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAM9E,MAAMC,aAAa;AAkBnB;;;;;;;;CAQC,GACD,OAAO,MAAMC,uBAIT,CAAC,EAAEC,iBAAiB,IAAI,EAAEC,WAAW,EAA+B;IACtE,OAAO;QACLC,gBAAgBN,eAAeO,gBAAgB;QAC/CC,YAAYN;QACZE;QACAK,sBAAsBC,kBAAkBL;QACxCM,cAAc;YAACV,YAAYW,IAAI;SAAC;IAClC;AACF,EAAE;AAEF,MAAMP,cAAuD;IAC3DQ,WAAW;AACb;AAEA,OAAO,MAAMC,mBAAmBC,OAAOC,MAAM,CAAC;IAC5CR,YAAYN;IACZC;IACAE;AACF,GAAY;AAEZ;;;;;;CAMC,GACD,OAAO,SAASK,kBAAkB,EAAEG,SAAS,EAAwB;IACnE,OAAO,eAAeI,eACpBC,KAA0D;QAE1D,OAAOL;IACT;AACF"}

package/dist/esm/restricted/index.js

@@ -1,27 +0,0 @@
-import { dialogBuilder } from './dialog';
-import { getBip32EntropyBuilder } from './getBip32Entropy';
-import { getBip32PublicKeyBuilder } from './getBip32PublicKey';
-import { getBip44EntropyBuilder } from './getBip44Entropy';
-import { getEntropyBuilder } from './getEntropy';
-import { getLocaleBuilder } from './getLocale';
-import { invokeSnapBuilder } from './invokeSnap';
-import { manageAccountsBuilder } from './manageAccounts';
-import { manageStateBuilder } from './manageState';
-import { notifyBuilder } from './notify';
-export { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';
-export { getEncryptionKey } from './manageState';
-export const restrictedMethodPermissionBuilders = {
-    [dialogBuilder.targetName]: dialogBuilder,
-    [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,
-    [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,
-    [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,
-    [getEntropyBuilder.targetName]: getEntropyBuilder,
-    [invokeSnapBuilder.targetName]: invokeSnapBuilder,
-    [manageStateBuilder.targetName]: manageStateBuilder,
-    [notifyBuilder.targetName]: notifyBuilder,
-    [manageAccountsBuilder.targetName]: manageAccountsBuilder,
-    [getLocaleBuilder.targetName]: getLocaleBuilder
-};
-export * from './caveats';
-
-//# sourceMappingURL=index.js.map

package/dist/esm/restricted/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/index.ts"],"sourcesContent":["import type { DialogMethodHooks } from './dialog';\nimport { dialogBuilder } from './dialog';\nimport type { GetBip32EntropyMethodHooks } from './getBip32Entropy';\nimport { getBip32EntropyBuilder } from './getBip32Entropy';\nimport type { GetBip32PublicKeyMethodHooks } from './getBip32PublicKey';\nimport { getBip32PublicKeyBuilder } from './getBip32PublicKey';\nimport type { GetBip44EntropyMethodHooks } from './getBip44Entropy';\nimport { getBip44EntropyBuilder } from './getBip44Entropy';\nimport type { GetEntropyHooks } from './getEntropy';\nimport { getEntropyBuilder } from './getEntropy';\nimport type { GetLocaleMethodHooks } from './getLocale';\nimport { getLocaleBuilder } from './getLocale';\nimport type { InvokeSnapMethodHooks } from './invokeSnap';\nimport { invokeSnapBuilder } from './invokeSnap';\nimport type { ManageAccountsMethodHooks } from './manageAccounts';\nimport { manageAccountsBuilder } from './manageAccounts';\nimport type { ManageStateMethodHooks } from './manageState';\nimport { manageStateBuilder } from './manageState';\nimport type { NotifyMethodHooks } from './notify';\nimport { notifyBuilder } from './notify';\n\nexport { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';\nexport { getEncryptionKey } from './manageState';\n\nexport type RestrictedMethodHooks = DialogMethodHooks &\n  GetBip32EntropyMethodHooks &\n  GetBip32PublicKeyMethodHooks &\n  GetBip44EntropyMethodHooks &\n  GetEntropyHooks &\n  InvokeSnapMethodHooks &\n  ManageStateMethodHooks &\n  NotifyMethodHooks &\n  ManageAccountsMethodHooks &\n  GetLocaleMethodHooks;\n\nexport const restrictedMethodPermissionBuilders = {\n  [dialogBuilder.targetName]: dialogBuilder,\n  [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,\n  [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,\n  [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,\n  [getEntropyBuilder.targetName]: getEntropyBuilder,\n  [invokeSnapBuilder.targetName]: invokeSnapBuilder,\n  [manageStateBuilder.targetName]: manageStateBuilder,\n  [notifyBuilder.targetName]: notifyBuilder,\n  [manageAccountsBuilder.targetName]: manageAccountsBuilder,\n  [getLocaleBuilder.targetName]: getLocaleBuilder,\n} as const;\n\nexport * from './caveats';\n"],"names":["dialogBuilder","getBip32EntropyBuilder","getBip32PublicKeyBuilder","getBip44EntropyBuilder","getEntropyBuilder","getLocaleBuilder","invokeSnapBuilder","manageAccountsBuilder","manageStateBuilder","notifyBuilder","WALLET_SNAP_PERMISSION_KEY","getEncryptionKey","restrictedMethodPermissionBuilders","targetName"],"mappings":"AACA,SAASA,aAAa,QAAQ,WAAW;AAEzC,SAASC,sBAAsB,QAAQ,oBAAoB;AAE3D,SAASC,wBAAwB,QAAQ,sBAAsB;AAE/D,SAASC,sBAAsB,QAAQ,oBAAoB;AAE3D,SAASC,iBAAiB,QAAQ,eAAe;AAEjD,SAASC,gBAAgB,QAAQ,cAAc;AAE/C,SAASC,iBAAiB,QAAQ,eAAe;AAEjD,SAASC,qBAAqB,QAAQ,mBAAmB;AAEzD,SAASC,kBAAkB,QAAQ,gBAAgB;AAEnD,SAASC,aAAa,QAAQ,WAAW;AAEzC,SAASC,0BAA0B,QAAQ,eAAe;AAC1D,SAASC,gBAAgB,QAAQ,gBAAgB;AAajD,OAAO,MAAMC,qCAAqC;IAChD,CAACZ,cAAca,UAAU,CAAC,EAAEb;IAC5B,CAACC,uBAAuBY,UAAU,CAAC,EAAEZ;IACrC,CAACC,yBAAyBW,UAAU,CAAC,EAAEX;IACvC,CAACC,uBAAuBU,UAAU,CAAC,EAAEV;IACrC,CAACC,kBAAkBS,UAAU,CAAC,EAAET;IAChC,CAACE,kBAAkBO,UAAU,CAAC,EAAEP;IAChC,CAACE,mBAAmBK,UAAU,CAAC,EAAEL;IACjC,CAACC,cAAcI,UAAU,CAAC,EAAEJ;IAC5B,CAACF,sBAAsBM,UAAU,CAAC,EAAEN;IACpC,CAACF,iBAAiBQ,UAAU,CAAC,EAAER;AACjC,EAAW;AAEX,cAAc,YAAY"}

package/dist/esm/restricted/invokeSnap.js

@@ -1,89 +0,0 @@
-import { PermissionType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { HandlerType, SnapCaveatType } from '@metamask/snaps-utils';
-export const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';
-/**
- * The side-effect method to handle the snap install.
- *
- * @param params - The side-effect params.
- * @param params.requestData - The request data associated to the requested permission.
- * @param params.messagingSystem - The messenger to call an action.
- */ export const handleSnapInstall = async ({ requestData, messagingSystem })=>{
-    const snaps = requestData.permissions[WALLET_SNAP_PERMISSION_KEY].caveats?.[0].value;
-    const permittedSnaps = messagingSystem.call(`SnapController:getPermitted`, requestData.metadata.origin);
-    const dedupedSnaps = Object.keys(snaps).reduce((filteredSnaps, snap)=>{
-        if (!permittedSnaps[snap]) {
-            filteredSnaps[snap] = snaps[snap];
-        }
-        return filteredSnaps;
-    }, {});
-    return messagingSystem.call(`SnapController:install`, requestData.metadata.origin, dedupedSnaps);
-};
-/**
- * The specification builder for the `wallet_snap_*` permission.
- *
- * `wallet_snap_*` attempts to invoke an RPC method of the specified Snap.
- *
- * Requesting its corresponding permission will attempt to connect to the Snap,
- * and install it if it's not available yet.
- *
- * @param options - The specification builder options.
- * @param options.methodHooks - The RPC method hooks needed by the method implementation.
- * @returns The specification for the `wallet_snap_*` permission.
- */ const specificationBuilder = ({ methodHooks })=>{
-    return {
-        permissionType: PermissionType.RestrictedMethod,
-        targetName: WALLET_SNAP_PERMISSION_KEY,
-        allowedCaveats: [
-            SnapCaveatType.SnapIds
-        ],
-        methodImplementation: getInvokeSnapImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.SnapIds) {
-                throw rpcErrors.invalidParams({
-                    message: `Expected a single "${SnapCaveatType.SnapIds}" caveat.`
-                });
-            }
-        },
-        sideEffect: {
-            onPermitted: handleSnapInstall
-        }
-    };
-};
-const methodHooks = {
-    getSnap: true,
-    handleSnapRpcRequest: true
-};
-export const invokeSnapBuilder = Object.freeze({
-    targetName: WALLET_SNAP_PERMISSION_KEY,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `wallet_snap_*`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.getSnap - A function that retrieves all information stored about a snap.
- * @param hooks.handleSnapRpcRequest - A function that sends an RPC request to a snap's RPC handler or throws if that fails.
- * @returns The method implementation which returns the result of `handleSnapRpcRequest`.
- * @throws If the params are invalid.
- */ export function getInvokeSnapImplementation({ getSnap, handleSnapRpcRequest }) {
-    return async function invokeSnap(options) {
-        const { params = {}, context } = options;
-        const { snapId, request } = params;
-        if (!getSnap(snapId)) {
-            throw rpcErrors.invalidRequest({
-                message: `The snap "${snapId}" is not installed. Please install it first, before invoking the snap.`
-            });
-        }
-        const { origin } = context;
-        return await handleSnapRpcRequest({
-            snapId,
-            origin,
-            request,
-            handler: HandlerType.OnRpcRequest
-        });
-    };
-}
-
-//# sourceMappingURL=invokeSnap.js.map

package/dist/esm/restricted/invokeSnap.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/invokeSnap.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n  PermissionValidatorConstraint,\n  PermissionSideEffect,\n} from '@metamask/permission-controller';\nimport { PermissionType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  InvokeSnapResult,\n  RequestSnapsParams,\n  RequestSnapsResult,\n} from '@metamask/snaps-sdk';\nimport type { Snap, SnapRpcHookArgs } from '@metamask/snaps-utils';\nimport { HandlerType, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nexport const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';\n\n// Redeclare installSnaps action type to avoid circular dependencies\nexport type InstallSnaps = {\n  type: `SnapController:install`;\n  handler: (\n    origin: string,\n    requestedSnaps: RequestSnapsParams,\n  ) => Promise<RequestSnapsResult>;\n};\n\nexport type GetPermittedSnaps = {\n  type: `SnapController:getPermitted`;\n  handler: (origin: string) => RequestSnapsResult;\n};\n\ntype AllowedActions = InstallSnaps | GetPermittedSnaps;\n\nexport type InvokeSnapMethodHooks = {\n  getSnap: (snapId: string) => Snap | undefined;\n  handleSnapRpcRequest: ({\n    snapId,\n    origin,\n    handler,\n    request,\n  }: SnapRpcHookArgs & { snapId: string }) => Promise<unknown>;\n};\n\ntype InvokeSnapSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: InvokeSnapMethodHooks;\n};\n\ntype InvokeSnapSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof WALLET_SNAP_PERMISSION_KEY;\n  methodImplementation: ReturnType<typeof getInvokeSnapImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n  sideEffect: {\n    onPermitted: PermissionSideEffect<AllowedActions, never>['onPermitted'];\n  };\n}>;\n\nexport type InvokeSnapParams = {\n  snapId: string;\n  request: Record<string, Json>;\n};\n\n/**\n * The side-effect method to handle the snap install.\n *\n * @param params - The side-effect params.\n * @param params.requestData - The request data associated to the requested permission.\n * @param params.messagingSystem - The messenger to call an action.\n */\nexport const handleSnapInstall: PermissionSideEffect<\n  AllowedActions,\n  never\n>['onPermitted'] = async ({ requestData, messagingSystem }) => {\n  const snaps = requestData.permissions[WALLET_SNAP_PERMISSION_KEY].caveats?.[0]\n    .value as RequestSnapsParams;\n\n  const permittedSnaps = messagingSystem.call(\n    `SnapController:getPermitted`,\n    requestData.metadata.origin,\n  );\n\n  const dedupedSnaps = Object.keys(snaps).reduce<RequestSnapsParams>(\n    (filteredSnaps, snap) => {\n      if (!permittedSnaps[snap]) {\n        filteredSnaps[snap] = snaps[snap];\n      }\n      return filteredSnaps;\n    },\n    {},\n  );\n\n  return messagingSystem.call(\n    `SnapController:install`,\n    requestData.metadata.origin,\n    dedupedSnaps,\n  );\n};\n/**\n * The specification builder for the `wallet_snap_*` permission.\n *\n * `wallet_snap_*` attempts to invoke an RPC method of the specified Snap.\n *\n * Requesting its corresponding permission will attempt to connect to the Snap,\n * and install it if it's not available yet.\n *\n * @param options - The specification builder options.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `wallet_snap_*` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  InvokeSnapSpecificationBuilderOptions,\n  InvokeSnapSpecification\n> = ({ methodHooks }: InvokeSnapSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: WALLET_SNAP_PERMISSION_KEY,\n    allowedCaveats: [SnapCaveatType.SnapIds],\n    methodImplementation: getInvokeSnapImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.SnapIds) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.SnapIds}\" caveat.`,\n        });\n      }\n    },\n    sideEffect: {\n      onPermitted: handleSnapInstall,\n    },\n  };\n};\n\nconst methodHooks: MethodHooksObject<InvokeSnapMethodHooks> = {\n  getSnap: true,\n  handleSnapRpcRequest: true,\n};\n\nexport const invokeSnapBuilder = Object.freeze({\n  targetName: WALLET_SNAP_PERMISSION_KEY,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `wallet_snap_*`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getSnap - A function that retrieves all information stored about a snap.\n * @param hooks.handleSnapRpcRequest - A function that sends an RPC request to a snap's RPC handler or throws if that fails.\n * @returns The method implementation which returns the result of `handleSnapRpcRequest`.\n * @throws If the params are invalid.\n */\nexport function getInvokeSnapImplementation({\n  getSnap,\n  handleSnapRpcRequest,\n}: InvokeSnapMethodHooks) {\n  return async function invokeSnap(\n    options: RestrictedMethodOptions<InvokeSnapParams>,\n  ): Promise<InvokeSnapResult> {\n    const { params = {}, context } = options;\n\n    const { snapId, request } = params as InvokeSnapParams;\n\n    if (!getSnap(snapId)) {\n      throw rpcErrors.invalidRequest({\n        message: `The snap \"${snapId}\" is not installed. Please install it first, before invoking the snap.`,\n      });\n    }\n\n    const { origin } = context;\n\n    return (await handleSnapRpcRequest({\n      snapId,\n      origin,\n      request,\n      handler: HandlerType.OnRpcRequest,\n    })) as Json;\n  };\n}\n"],"names":["PermissionType","rpcErrors","HandlerType","SnapCaveatType","WALLET_SNAP_PERMISSION_KEY","handleSnapInstall","requestData","messagingSystem","snaps","permissions","caveats","value","permittedSnaps","call","metadata","origin","dedupedSnaps","Object","keys","reduce","filteredSnaps","snap","specificationBuilder","methodHooks","permissionType","RestrictedMethod","targetName","allowedCaveats","SnapIds","methodImplementation","getInvokeSnapImplementation","validator","length","type","invalidParams","message","sideEffect","onPermitted","getSnap","handleSnapRpcRequest","invokeSnapBuilder","freeze","invokeSnap","options","params","context","snapId","request","invalidRequest","handler","OnRpcRequest"],"mappings":"AAOA,SAASA,cAAc,QAAQ,kCAAkC;AACjE,SAASC,SAAS,QAAQ,uBAAuB;AAOjD,SAASC,WAAW,EAAEC,cAAc,QAAQ,wBAAwB;AAKpE,OAAO,MAAMC,6BAA6B,cAAc;AAiDxD;;;;;;CAMC,GACD,OAAO,MAAMC,oBAGM,OAAO,EAAEC,WAAW,EAAEC,eAAe,EAAE;IACxD,MAAMC,QAAQF,YAAYG,WAAW,CAACL,2BAA2B,CAACM,OAAO,EAAE,CAAC,EAAE,CAC3EC;IAEH,MAAMC,iBAAiBL,gBAAgBM,IAAI,CACzC,CAAC,2BAA2B,CAAC,EAC7BP,YAAYQ,QAAQ,CAACC,MAAM;IAG7B,MAAMC,eAAeC,OAAOC,IAAI,CAACV,OAAOW,MAAM,CAC5C,CAACC,eAAeC;QACd,IAAI,CAACT,cAAc,CAACS,KAAK,EAAE;YACzBD,aAAa,CAACC,KAAK,GAAGb,KAAK,CAACa,KAAK;QACnC;QACA,OAAOD;IACT,GACA,CAAC;IAGH,OAAOb,gBAAgBM,IAAI,CACzB,CAAC,sBAAsB,CAAC,EACxBP,YAAYQ,QAAQ,CAACC,MAAM,EAC3BC;AAEJ,EAAE;AACF;;;;;;;;;;;CAWC,GACD,MAAMM,uBAIF,CAAC,EAAEC,WAAW,EAAyC;IACzD,OAAO;QACLC,gBAAgBxB,eAAeyB,gBAAgB;QAC/CC,YAAYtB;QACZuB,gBAAgB;YAACxB,eAAeyB,OAAO;SAAC;QACxCC,sBAAsBC,4BAA4BP;QAClDQ,WAAW,CAAC,EAAErB,OAAO,EAAE;YACrB,IAAIA,SAASsB,WAAW,KAAKtB,OAAO,CAAC,EAAE,CAACuB,IAAI,KAAK9B,eAAeyB,OAAO,EAAE;gBACvE,MAAM3B,UAAUiC,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAEhC,eAAeyB,OAAO,CAAC,SAAS,CAAC;gBAClE;YACF;QACF;QACAQ,YAAY;YACVC,aAAahC;QACf;IACF;AACF;AAEA,MAAMkB,cAAwD;IAC5De,SAAS;IACTC,sBAAsB;AACxB;AAEA,OAAO,MAAMC,oBAAoBvB,OAAOwB,MAAM,CAAC;IAC7Cf,YAAYtB;IACZkB;IACAC;AACF,GAAY;AAEZ;;;;;;;;CAQC,GACD,OAAO,SAASO,4BAA4B,EAC1CQ,OAAO,EACPC,oBAAoB,EACE;IACtB,OAAO,eAAeG,WACpBC,OAAkD;QAElD,MAAM,EAAEC,SAAS,CAAC,CAAC,EAAEC,OAAO,EAAE,GAAGF;QAEjC,MAAM,EAAEG,MAAM,EAAEC,OAAO,EAAE,GAAGH;QAE5B,IAAI,CAACN,QAAQQ,SAAS;YACpB,MAAM7C,UAAU+C,cAAc,CAAC;gBAC7Bb,SAAS,CAAC,UAAU,EAAEW,OAAO,sEAAsE,CAAC;YACtG;QACF;QAEA,MAAM,EAAE/B,MAAM,EAAE,GAAG8B;QAEnB,OAAQ,MAAMN,qBAAqB;YACjCO;YACA/B;YACAgC;YACAE,SAAS/C,YAAYgD,YAAY;QACnC;IACF;AACF"}

package/dist/esm/restricted/manageAccounts.js

@@ -1,60 +0,0 @@
-import { SubjectType, PermissionType } from '@metamask/permission-controller';
-import { JsonStruct } from '@metamask/utils';
-import { assert, string, object, union, array, record } from 'superstruct';
-const SnapMessageStruct = union([
-    object({
-        method: string()
-    }),
-    object({
-        method: string(),
-        params: union([
-            array(JsonStruct),
-            record(string(), JsonStruct)
-        ])
-    })
-]);
-export const methodName = 'snap_manageAccounts';
-/**
- * The specification builder for the `snap_manageAccounts` permission.
- * `snap_manageAccounts` lets the Snap manage a set of accounts via a custom keyring.
- *
- * @param options - The specification builder options.
- * @param options.allowedCaveats - The optional allowed caveats for the permission.
- * @param options.methodHooks - The RPC method hooks needed by the method implementation.
- * @returns The specification for the `snap_manageAccounts` permission.
- */ export const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: manageAccountsImplementation(methodHooks),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-/**
- * Builds the method implementation for `snap_manageAccounts`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.getSnapKeyring - A function to get the snap keyring.
- * @returns The method implementation which either returns `null` for a
- * successful state update/deletion or returns the decrypted state.
- * @throws If the params are invalid.
- */ export function manageAccountsImplementation({ getSnapKeyring }) {
-    return async function manageAccounts(options) {
-        const { context: { origin }, params } = options;
-        assert(params, SnapMessageStruct);
-        const keyring = await getSnapKeyring(origin);
-        return await keyring.handleKeyringSnapMessage(origin, params);
-    };
-}
-export const manageAccountsBuilder = Object.freeze({
-    targetName: methodName,
-    specificationBuilder,
-    methodHooks: {
-        getSnapKeyring: true
-    }
-});
-
-//# sourceMappingURL=manageAccounts.js.map

package/dist/esm/restricted/manageAccounts.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/manageAccounts.ts"],"sourcesContent":["import type {\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n  PermissionSpecificationBuilder,\n} from '@metamask/permission-controller';\nimport { SubjectType, PermissionType } from '@metamask/permission-controller';\nimport type {\n  ManageAccountsParams,\n  ManageAccountsResult,\n} from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { JsonStruct } from '@metamask/utils';\nimport { assert, string, object, union, array, record } from 'superstruct';\n\nconst SnapMessageStruct = union([\n  object({\n    method: string(),\n  }),\n  object({\n    method: string(),\n    params: union([array(JsonStruct), record(string(), JsonStruct)]),\n  }),\n]);\n\ntype Message = InferMatching<typeof SnapMessageStruct, ManageAccountsParams>;\n\nexport const methodName = 'snap_manageAccounts';\n\nexport type ManageAccountsMethodHooks = {\n  /**\n   * Gets the snap keyring implementation.\n   */\n  getSnapKeyring: (snapOrigin: string) => Promise<{\n    handleKeyringSnapMessage: (\n      snapId: string,\n      message: Message,\n    ) => Promise<Json>;\n  }>;\n};\n\ntype ManageAccountsSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: ManageAccountsMethodHooks;\n};\n\ntype ManageAccountsSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof manageAccountsImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_manageAccounts` permission.\n * `snap_manageAccounts` lets the Snap manage a set of accounts via a custom keyring.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_manageAccounts` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  ManageAccountsSpecificationBuilderOptions,\n  ManageAccountsSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: ManageAccountsSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: manageAccountsImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\n/**\n * Builds the method implementation for `snap_manageAccounts`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getSnapKeyring - A function to get the snap keyring.\n * @returns The method implementation which either returns `null` for a\n * successful state update/deletion or returns the decrypted state.\n * @throws If the params are invalid.\n */\nexport function manageAccountsImplementation({\n  getSnapKeyring,\n}: ManageAccountsMethodHooks) {\n  return async function manageAccounts(\n    options: RestrictedMethodOptions<ManageAccountsParams>,\n  ): Promise<ManageAccountsResult> {\n    const {\n      context: { origin },\n      params,\n    } = options;\n\n    assert(params, SnapMessageStruct);\n    const keyring = await getSnapKeyring(origin);\n    return await keyring.handleKeyringSnapMessage(origin, params);\n  };\n}\n\nexport const manageAccountsBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks: {\n    getSnapKeyring: true,\n  },\n} as const);\n"],"names":["SubjectType","PermissionType","JsonStruct","assert","string","object","union","array","record","SnapMessageStruct","method","params","methodName","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","manageAccountsImplementation","subjectTypes","Snap","getSnapKeyring","manageAccounts","options","context","origin","keyring","handleKeyringSnapMessage","manageAccountsBuilder","Object","freeze"],"mappings":"AAKA,SAASA,WAAW,EAAEC,cAAc,QAAQ,kCAAkC;AAO9E,SAASC,UAAU,QAAQ,kBAAkB;AAC7C,SAASC,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,MAAM,QAAQ,cAAc;AAE3E,MAAMC,oBAAoBH,MAAM;IAC9BD,OAAO;QACLK,QAAQN;IACV;IACAC,OAAO;QACLK,QAAQN;QACRO,QAAQL,MAAM;YAACC,MAAML;YAAaM,OAAOJ,UAAUF;SAAY;IACjE;CACD;AAID,OAAO,MAAMU,aAAa,sBAAsB;AA0BhD;;;;;;;;CAQC,GACD,OAAO,MAAMC,uBAIT,CAAC,EACHC,iBAAiB,IAAI,EACrBC,WAAW,EAC+B;IAC1C,OAAO;QACLC,gBAAgBf,eAAegB,gBAAgB;QAC/CC,YAAYN;QACZE;QACAK,sBAAsBC,6BAA6BL;QACnDM,cAAc;YAACrB,YAAYsB,IAAI;SAAC;IAClC;AACF,EAAE;AAEF;;;;;;;;CAQC,GACD,OAAO,SAASF,6BAA6B,EAC3CG,cAAc,EACY;IAC1B,OAAO,eAAeC,eACpBC,OAAsD;QAEtD,MAAM,EACJC,SAAS,EAAEC,MAAM,EAAE,EACnBhB,MAAM,EACP,GAAGc;QAEJtB,OAAOQ,QAAQF;QACf,MAAMmB,UAAU,MAAML,eAAeI;QACrC,OAAO,MAAMC,QAAQC,wBAAwB,CAACF,QAAQhB;IACxD;AACF;AAEA,OAAO,MAAMmB,wBAAwBC,OAAOC,MAAM,CAAC;IACjDd,YAAYN;IACZC;IACAE,aAAa;QACXQ,gBAAgB;IAClB;AACF,GAAY"}

package/dist/esm/restricted/manageState.js

@@ -1,225 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { ManageStateOperation } from '@metamask/snaps-sdk';
-import { STATE_ENCRYPTION_MAGIC_VALUE, parseJson } from '@metamask/snaps-utils';
-import { isObject, getJsonSize, assert, isValidJson } from '@metamask/utils';
-import { deriveEntropy } from '../utils';
-// The salt used for SIP-6-based entropy derivation.
-export const STATE_ENCRYPTION_SALT = 'snap_manageState encryption';
-const methodName = 'snap_manageState';
-/**
- * The specification builder for the `snap_manageState` permission.
- * `snap_manageState` lets the Snap store and manage some of its state on
- * your device.
- *
- * @param options - The specification builder options.
- * @param options.allowedCaveats - The optional allowed caveats for the permission.
- * @param options.methodHooks - The RPC method hooks needed by the method implementation.
- * @returns The specification for the `snap_manageState` permission.
- */ export const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: getManageStateImplementation(methodHooks),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true,
-    clearSnapState: true,
-    getSnapState: true,
-    updateSnapState: true,
-    encrypt: true,
-    decrypt: true
-};
-export const manageStateBuilder = Object.freeze({
-    targetName: methodName,
-    specificationBuilder,
-    methodHooks
-});
-export const STORAGE_SIZE_LIMIT = 104857600; // In bytes (100MB)
-/**
- * Get a deterministic encryption key to use for encrypting and decrypting the
- * state.
- *
- * This key should only be used for state encryption using `snap_manageState`.
- * To get other encryption keys, a different salt can be used.
- *
- * @param args - The encryption key args.
- * @param args.snapId - The ID of the snap to get the encryption key for.
- * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key
- * from.
- * @returns The state encryption key.
- */ export async function getEncryptionKey({ mnemonicPhrase, snapId }) {
-    return await deriveEntropy({
-        mnemonicPhrase,
-        input: snapId,
-        salt: STATE_ENCRYPTION_SALT,
-        magic: STATE_ENCRYPTION_MAGIC_VALUE
-    });
-}
-/**
- * Encrypt the state using a deterministic encryption algorithm, based on the
- * snap ID and mnemonic phrase.
- *
- * @param args - The encryption args.
- * @param args.state - The state to encrypt.
- * @param args.encryptFunction - The function to use for encrypting the state.
- * @param args.snapId - The ID of the snap to get the encryption key for.
- * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key
- * from.
- * @returns The encrypted state.
- */ async function encryptState({ state, encryptFunction, ...keyArgs }) {
-    const encryptionKey = await getEncryptionKey(keyArgs);
-    return await encryptFunction(encryptionKey, state);
-}
-/**
- * Decrypt the state using a deterministic decryption algorithm, based on the
- * snap ID and mnemonic phrase.
- *
- * @param args - The encryption args.
- * @param args.state - The state to decrypt.
- * @param args.decryptFunction - The function to use for decrypting the state.
- * @param args.snapId - The ID of the snap to get the encryption key for.
- * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key
- * from.
- * @returns The encrypted state.
- */ async function decryptState({ state, decryptFunction, ...keyArgs }) {
-    try {
-        const encryptionKey = await getEncryptionKey(keyArgs);
-        const decryptedState = await decryptFunction(encryptionKey, state);
-        assert(isValidJson(decryptedState));
-        return decryptedState;
-    } catch  {
-        throw rpcErrors.internal({
-            message: 'Failed to decrypt snap state, the state must be corrupted.'
-        });
-    }
-}
-/**
- * Builds the method implementation for `snap_manageState`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.clearSnapState - A function that clears the state stored for a
- * snap.
- * @param hooks.getSnapState - A function that fetches the persisted decrypted
- * state for a snap.
- * @param hooks.updateSnapState - A function that updates the state stored for a
- * snap.
- * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase
- * of the user.
- * @param hooks.getUnlockPromise - A function that resolves once the MetaMask
- * extension is unlocked and prompts the user to unlock their MetaMask if it is
- * locked.
- * @param hooks.encrypt - A function that encrypts the given state.
- * @param hooks.decrypt - A function that decrypts the given state.
- * @returns The method implementation which either returns `null` for a
- * successful state update/deletion or returns the decrypted state.
- * @throws If the params are invalid.
- */ export function getManageStateImplementation({ getMnemonic, getUnlockPromise, clearSnapState, getSnapState, updateSnapState, encrypt, decrypt }) {
-    return async function manageState(options) {
-        const { params = {}, method, context: { origin } } = options;
-        const validatedParams = getValidatedParams(params, method);
-        // If the encrypted param is undefined or null we default to true.
-        const shouldEncrypt = validatedParams.encrypted ?? true;
-        // We only need to prompt the user when the mnemonic is needed
-        // which it isn't for the clear operation or unencrypted storage.
-        if (shouldEncrypt && validatedParams.operation !== ManageStateOperation.ClearState) {
-            await getUnlockPromise(true);
-        }
-        switch(validatedParams.operation){
-            case ManageStateOperation.ClearState:
-                clearSnapState(origin, shouldEncrypt);
-                return null;
-            case ManageStateOperation.GetState:
-                {
-                    const state = getSnapState(origin, shouldEncrypt);
-                    if (state === null) {
-                        return state;
-                    }
-                    return shouldEncrypt ? await decryptState({
-                        state,
-                        decryptFunction: decrypt,
-                        mnemonicPhrase: await getMnemonic(),
-                        snapId: origin
-                    }) : parseJson(state);
-                }
-            case ManageStateOperation.UpdateState:
-                {
-                    const finalizedState = shouldEncrypt ? await encryptState({
-                        state: validatedParams.newState,
-                        encryptFunction: encrypt,
-                        mnemonicPhrase: await getMnemonic(),
-                        snapId: origin
-                    }) : JSON.stringify(validatedParams.newState);
-                    updateSnapState(origin, finalizedState, shouldEncrypt);
-                    return null;
-                }
-            default:
-                throw rpcErrors.invalidParams(`Invalid ${method} operation: "${validatedParams.operation}"`);
-        }
-    };
-}
-/**
- * Validates the manageState method `params` and returns them cast to the correct
- * type. Throws if validation fails.
- *
- * @param params - The unvalidated params object from the method request.
- * @param method - RPC method name used for debugging errors.
- * @param storageSizeLimit - Maximum allowed size (in bytes) of a new state object.
- * @returns The validated method parameter object.
- */ export function getValidatedParams(params, method, storageSizeLimit = STORAGE_SIZE_LIMIT) {
-    if (!isObject(params)) {
-        throw rpcErrors.invalidParams({
-            message: 'Expected params to be a single object.'
-        });
-    }
-    const { operation, newState, encrypted } = params;
-    if (!operation || typeof operation !== 'string' || !Object.values(ManageStateOperation).includes(operation)) {
-        throw rpcErrors.invalidParams({
-            message: 'Must specify a valid manage state "operation".'
-        });
-    }
-    if (encrypted !== undefined && typeof encrypted !== 'boolean') {
-        throw rpcErrors.invalidParams({
-            message: '"encrypted" parameter must be a boolean if specified.'
-        });
-    }
-    if (operation === ManageStateOperation.UpdateState) {
-        if (!isObject(newState)) {
-            throw rpcErrors.invalidParams({
-                message: `Invalid ${method} "updateState" parameter: The new state must be a plain object.`,
-                data: {
-                    receivedNewState: typeof newState === 'undefined' ? 'undefined' : newState
-                }
-            });
-        }
-        let size;
-        try {
-            // `getJsonSize` will throw if the state is not JSON serializable.
-            size = getJsonSize(newState);
-        } catch  {
-            throw rpcErrors.invalidParams({
-                message: `Invalid ${method} "updateState" parameter: The new state must be JSON serializable.`,
-                data: {
-                    receivedNewState: typeof newState === 'undefined' ? 'undefined' : newState
-                }
-            });
-        }
-        if (size > storageSizeLimit) {
-            throw rpcErrors.invalidParams({
-                message: `Invalid ${method} "updateState" parameter: The new state must not exceed ${storageSizeLimit} bytes in size.`,
-                data: {
-                    receivedNewState: typeof newState === 'undefined' ? 'undefined' : newState
-                }
-            });
-        }
-    }
-    return params;
-}
-
-//# sourceMappingURL=manageState.js.map

package/dist/esm/restricted/manageState.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/manageState.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { ManageStateParams, ManageStateResult } from '@metamask/snaps-sdk';\nimport { ManageStateOperation } from '@metamask/snaps-sdk';\nimport { STATE_ENCRYPTION_MAGIC_VALUE, parseJson } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray, Hex } from '@metamask/utils';\nimport { isObject, getJsonSize, assert, isValidJson } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\n// The salt used for SIP-6-based entropy derivation.\nexport const STATE_ENCRYPTION_SALT = 'snap_manageState encryption';\n\nconst methodName = 'snap_manageState';\n\nexport type ManageStateMethodHooks = {\n  /**\n   * @returns The mnemonic of the user's primary keyring.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * Waits for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n\n  /**\n   * A function that clears the state of the requesting Snap.\n   */\n  clearSnapState: (snapId: string, encrypted: boolean) => void;\n\n  /**\n   * A function that gets the encrypted state of the requesting Snap.\n   *\n   * @returns The current state of the Snap.\n   */\n  getSnapState: (snapId: string, encrypted: boolean) => string;\n\n  /**\n   * A function that updates the state of the requesting Snap.\n   *\n   * @param newState - The new state of the Snap.\n   */\n  updateSnapState: (\n    snapId: string,\n    newState: string,\n    encrypted: boolean,\n  ) => void;\n\n  /**\n   * Encrypts data with a key. This is assumed to perform symmetric encryption.\n   *\n   * @param key - The key to use for encryption, in hexadecimal format.\n   * @param data - The JSON data to encrypt.\n   * @returns The ciphertext as a string. The format for this string is\n   * dependent on the implementation, but MUST be a string.\n   */\n  encrypt: (key: string, data: Json) => Promise<string>;\n\n  /**\n   * Decrypts data with a key. This is assumed to perform symmetric decryption.\n   *\n   * @param key - The key to use for decryption, in hexadecimal format.\n   * @param cipherText - The ciphertext to decrypt. The format for this string\n   * is dependent on the implementation, but MUST be a string.\n   * @returns The decrypted data as a JSON object.\n   */\n  decrypt: (key: Hex, cipherText: string) => Promise<unknown>;\n};\n\ntype ManageStateSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: ManageStateMethodHooks;\n};\n\ntype ManageStateSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getManageStateImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_manageState` permission.\n * `snap_manageState` lets the Snap store and manage some of its state on\n * your device.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_manageState` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  ManageStateSpecificationBuilderOptions,\n  ManageStateSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: ManageStateSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getManageStateImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<ManageStateMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n  clearSnapState: true,\n  getSnapState: true,\n  updateSnapState: true,\n  encrypt: true,\n  decrypt: true,\n};\n\nexport const manageStateBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport const STORAGE_SIZE_LIMIT = 104857600; // In bytes (100MB)\n\ntype GetEncryptionKeyArgs = {\n  snapId: string;\n  mnemonicPhrase: Uint8Array;\n};\n\n/**\n * Get a deterministic encryption key to use for encrypting and decrypting the\n * state.\n *\n * This key should only be used for state encryption using `snap_manageState`.\n * To get other encryption keys, a different salt can be used.\n *\n * @param args - The encryption key args.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The state encryption key.\n */\nexport async function getEncryptionKey({\n  mnemonicPhrase,\n  snapId,\n}: GetEncryptionKeyArgs) {\n  return await deriveEntropy({\n    mnemonicPhrase,\n    input: snapId,\n    salt: STATE_ENCRYPTION_SALT,\n    magic: STATE_ENCRYPTION_MAGIC_VALUE,\n  });\n}\n\ntype EncryptStateArgs = GetEncryptionKeyArgs & {\n  state: Json;\n  encryptFunction: ManageStateMethodHooks['encrypt'];\n};\n\n/**\n * Encrypt the state using a deterministic encryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to encrypt.\n * @param args.encryptFunction - The function to use for encrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function encryptState({\n  state,\n  encryptFunction,\n  ...keyArgs\n}: EncryptStateArgs) {\n  const encryptionKey = await getEncryptionKey(keyArgs);\n  return await encryptFunction(encryptionKey, state);\n}\n\ntype DecryptStateArgs = GetEncryptionKeyArgs & {\n  state: string;\n  decryptFunction: ManageStateMethodHooks['decrypt'];\n};\n\n/**\n * Decrypt the state using a deterministic decryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to decrypt.\n * @param args.decryptFunction - The function to use for decrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function decryptState({\n  state,\n  decryptFunction,\n  ...keyArgs\n}: DecryptStateArgs) {\n  try {\n    const encryptionKey = await getEncryptionKey(keyArgs);\n    const decryptedState = await decryptFunction(encryptionKey, state);\n\n    assert(isValidJson(decryptedState));\n\n    return decryptedState as Record<string, Json>;\n  } catch {\n    throw rpcErrors.internal({\n      message: 'Failed to decrypt snap state, the state must be corrupted.',\n    });\n  }\n}\n\n/**\n * Builds the method implementation for `snap_manageState`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.clearSnapState - A function that clears the state stored for a\n * snap.\n * @param hooks.getSnapState - A function that fetches the persisted decrypted\n * state for a snap.\n * @param hooks.updateSnapState - A function that updates the state stored for a\n * snap.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase\n * of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask\n * extension is unlocked and prompts the user to unlock their MetaMask if it is\n * locked.\n * @param hooks.encrypt - A function that encrypts the given state.\n * @param hooks.decrypt - A function that decrypts the given state.\n * @returns The method implementation which either returns `null` for a\n * successful state update/deletion or returns the decrypted state.\n * @throws If the params are invalid.\n */\nexport function getManageStateImplementation({\n  getMnemonic,\n  getUnlockPromise,\n  clearSnapState,\n  getSnapState,\n  updateSnapState,\n  encrypt,\n  decrypt,\n}: ManageStateMethodHooks) {\n  return async function manageState(\n    options: RestrictedMethodOptions<ManageStateParams>,\n  ): Promise<ManageStateResult> {\n    const {\n      params = {},\n      method,\n      context: { origin },\n    } = options;\n    const validatedParams = getValidatedParams(params, method);\n\n    // If the encrypted param is undefined or null we default to true.\n    const shouldEncrypt = validatedParams.encrypted ?? true;\n\n    // We only need to prompt the user when the mnemonic is needed\n    // which it isn't for the clear operation or unencrypted storage.\n    if (\n      shouldEncrypt &&\n      validatedParams.operation !== ManageStateOperation.ClearState\n    ) {\n      await getUnlockPromise(true);\n    }\n\n    switch (validatedParams.operation) {\n      case ManageStateOperation.ClearState:\n        clearSnapState(origin, shouldEncrypt);\n        return null;\n\n      case ManageStateOperation.GetState: {\n        const state = getSnapState(origin, shouldEncrypt);\n        if (state === null) {\n          return state;\n        }\n        return shouldEncrypt\n          ? await decryptState({\n              state,\n              decryptFunction: decrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : parseJson<Record<string, Json>>(state);\n      }\n\n      case ManageStateOperation.UpdateState: {\n        const finalizedState = shouldEncrypt\n          ? await encryptState({\n              state: validatedParams.newState,\n              encryptFunction: encrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : JSON.stringify(validatedParams.newState);\n\n        updateSnapState(origin, finalizedState, shouldEncrypt);\n        return null;\n      }\n\n      default:\n        throw rpcErrors.invalidParams(\n          `Invalid ${method} operation: \"${\n            validatedParams.operation as string\n          }\"`,\n        );\n    }\n  };\n}\n\n/**\n * Validates the manageState method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @param method - RPC method name used for debugging errors.\n * @param storageSizeLimit - Maximum allowed size (in bytes) of a new state object.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(\n  params: unknown,\n  method: string,\n  storageSizeLimit = STORAGE_SIZE_LIMIT,\n): ManageStateParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { operation, newState, encrypted } = params;\n\n  if (\n    !operation ||\n    typeof operation !== 'string' ||\n    !Object.values(ManageStateOperation).includes(\n      operation as ManageStateOperation,\n    )\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid manage state \"operation\".',\n    });\n  }\n\n  if (encrypted !== undefined && typeof encrypted !== 'boolean') {\n    throw rpcErrors.invalidParams({\n      message: '\"encrypted\" parameter must be a boolean if specified.',\n    });\n  }\n\n  if (operation === ManageStateOperation.UpdateState) {\n    if (!isObject(newState)) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be a plain object.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    let size;\n    try {\n      // `getJsonSize` will throw if the state is not JSON serializable.\n      size = getJsonSize(newState);\n    } catch {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be JSON serializable.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    if (size > storageSizeLimit) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must not exceed ${storageSizeLimit} bytes in size.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n  }\n\n  return params as ManageStateParams;\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","ManageStateOperation","STATE_ENCRYPTION_MAGIC_VALUE","parseJson","isObject","getJsonSize","assert","isValidJson","deriveEntropy","STATE_ENCRYPTION_SALT","methodName","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","getManageStateImplementation","subjectTypes","Snap","getMnemonic","getUnlockPromise","clearSnapState","getSnapState","updateSnapState","encrypt","decrypt","manageStateBuilder","Object","freeze","STORAGE_SIZE_LIMIT","getEncryptionKey","mnemonicPhrase","snapId","input","salt","magic","encryptState","state","encryptFunction","keyArgs","encryptionKey","decryptState","decryptFunction","decryptedState","internal","message","manageState","options","params","method","context","origin","validatedParams","getValidatedParams","shouldEncrypt","encrypted","operation","ClearState","GetState","UpdateState","finalizedState","newState","JSON","stringify","invalidParams","storageSizeLimit","values","includes","undefined","data","receivedNewState","size"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAEjD,SAASC,oBAAoB,QAAQ,sBAAsB;AAC3D,SAASC,4BAA4B,EAAEC,SAAS,QAAQ,wBAAwB;AAEhF,SAASC,QAAQ,EAAEC,WAAW,EAAEC,MAAM,EAAEC,WAAW,QAAQ,kBAAkB;AAG7E,SAASC,aAAa,QAAQ,WAAW;AAEzC,oDAAoD;AACpD,OAAO,MAAMC,wBAAwB,8BAA8B;AAEnE,MAAMC,aAAa;AAuEnB;;;;;;;;;CASC,GACD,OAAO,MAAMC,uBAIT,CAAC,EACHC,iBAAiB,IAAI,EACrBC,WAAW,EAC4B;IACvC,OAAO;QACLC,gBAAgBhB,eAAeiB,gBAAgB;QAC/CC,YAAYN;QACZE;QACAK,sBAAsBC,6BAA6BL;QACnDM,cAAc;YAACpB,YAAYqB,IAAI;SAAC;IAClC;AACF,EAAE;AAEF,MAAMP,cAAyD;IAC7DQ,aAAa;IACbC,kBAAkB;IAClBC,gBAAgB;IAChBC,cAAc;IACdC,iBAAiB;IACjBC,SAAS;IACTC,SAAS;AACX;AAEA,OAAO,MAAMC,qBAAqBC,OAAOC,MAAM,CAAC;IAC9Cd,YAAYN;IACZC;IACAE;AACF,GAAY;AAEZ,OAAO,MAAMkB,qBAAqB,UAAU,CAAC,mBAAmB;AAOhE;;;;;;;;;;;;CAYC,GACD,OAAO,eAAeC,iBAAiB,EACrCC,cAAc,EACdC,MAAM,EACe;IACrB,OAAO,MAAM1B,cAAc;QACzByB;QACAE,OAAOD;QACPE,MAAM3B;QACN4B,OAAOnC;IACT;AACF;AAOA;;;;;;;;;;;CAWC,GACD,eAAeoC,aAAa,EAC1BC,KAAK,EACLC,eAAe,EACf,GAAGC,SACc;IACjB,MAAMC,gBAAgB,MAAMV,iBAAiBS;IAC7C,OAAO,MAAMD,gBAAgBE,eAAeH;AAC9C;AAOA;;;;;;;;;;;CAWC,GACD,eAAeI,aAAa,EAC1BJ,KAAK,EACLK,eAAe,EACf,GAAGH,SACc;IACjB,IAAI;QACF,MAAMC,gBAAgB,MAAMV,iBAAiBS;QAC7C,MAAMI,iBAAiB,MAAMD,gBAAgBF,eAAeH;QAE5DjC,OAAOC,YAAYsC;QAEnB,OAAOA;IACT,EAAE,OAAM;QACN,MAAM7C,UAAU8C,QAAQ,CAAC;YACvBC,SAAS;QACX;IACF;AACF;AAEA;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAAS7B,6BAA6B,EAC3CG,WAAW,EACXC,gBAAgB,EAChBC,cAAc,EACdC,YAAY,EACZC,eAAe,EACfC,OAAO,EACPC,OAAO,EACgB;IACvB,OAAO,eAAeqB,YACpBC,OAAmD;QAEnD,MAAM,EACJC,SAAS,CAAC,CAAC,EACXC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGJ;QACJ,MAAMK,kBAAkBC,mBAAmBL,QAAQC;QAEnD,kEAAkE;QAClE,MAAMK,gBAAgBF,gBAAgBG,SAAS,IAAI;QAEnD,8DAA8D;QAC9D,iEAAiE;QACjE,IACED,iBACAF,gBAAgBI,SAAS,KAAKzD,qBAAqB0D,UAAU,EAC7D;YACA,MAAMrC,iBAAiB;QACzB;QAEA,OAAQgC,gBAAgBI,SAAS;YAC/B,KAAKzD,qBAAqB0D,UAAU;gBAClCpC,eAAe8B,QAAQG;gBACvB,OAAO;YAET,KAAKvD,qBAAqB2D,QAAQ;gBAAE;oBAClC,MAAMrB,QAAQf,aAAa6B,QAAQG;oBACnC,IAAIjB,UAAU,MAAM;wBAClB,OAAOA;oBACT;oBACA,OAAOiB,gBACH,MAAMb,aAAa;wBACjBJ;wBACAK,iBAAiBjB;wBACjBM,gBAAgB,MAAMZ;wBACtBa,QAAQmB;oBACV,KACAlD,UAAgCoC;gBACtC;YAEA,KAAKtC,qBAAqB4D,WAAW;gBAAE;oBACrC,MAAMC,iBAAiBN,gBACnB,MAAMlB,aAAa;wBACjBC,OAAOe,gBAAgBS,QAAQ;wBAC/BvB,iBAAiBd;wBACjBO,gBAAgB,MAAMZ;wBACtBa,QAAQmB;oBACV,KACAW,KAAKC,SAAS,CAACX,gBAAgBS,QAAQ;oBAE3CtC,gBAAgB4B,QAAQS,gBAAgBN;oBACxC,OAAO;gBACT;YAEA;gBACE,MAAMxD,UAAUkE,aAAa,CAC3B,CAAC,QAAQ,EAAEf,OAAO,aAAa,EAC7BG,gBAAgBI,SAAS,CAC1B,CAAC,CAAC;QAET;IACF;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASH,mBACdL,MAAe,EACfC,MAAc,EACdgB,mBAAmBpC,kBAAkB;IAErC,IAAI,CAAC3B,SAAS8C,SAAS;QACrB,MAAMlD,UAAUkE,aAAa,CAAC;YAC5BnB,SAAS;QACX;IACF;IAEA,MAAM,EAAEW,SAAS,EAAEK,QAAQ,EAAEN,SAAS,EAAE,GAAGP;IAE3C,IACE,CAACQ,aACD,OAAOA,cAAc,YACrB,CAAC7B,OAAOuC,MAAM,CAACnE,sBAAsBoE,QAAQ,CAC3CX,YAEF;QACA,MAAM1D,UAAUkE,aAAa,CAAC;YAC5BnB,SAAS;QACX;IACF;IAEA,IAAIU,cAAca,aAAa,OAAOb,cAAc,WAAW;QAC7D,MAAMzD,UAAUkE,aAAa,CAAC;YAC5BnB,SAAS;QACX;IACF;IAEA,IAAIW,cAAczD,qBAAqB4D,WAAW,EAAE;QAClD,IAAI,CAACzD,SAAS2D,WAAW;YACvB,MAAM/D,UAAUkE,aAAa,CAAC;gBAC5BnB,SAAS,CAAC,QAAQ,EAAEI,OAAO,+DAA+D,CAAC;gBAC3FoB,MAAM;oBACJC,kBACE,OAAOT,aAAa,cAAc,cAAcA;gBACpD;YACF;QACF;QAEA,IAAIU;QACJ,IAAI;YACF,kEAAkE;YAClEA,OAAOpE,YAAY0D;QACrB,EAAE,OAAM;YACN,MAAM/D,UAAUkE,aAAa,CAAC;gBAC5BnB,SAAS,CAAC,QAAQ,EAAEI,OAAO,kEAAkE,CAAC;gBAC9FoB,MAAM;oBACJC,kBACE,OAAOT,aAAa,cAAc,cAAcA;gBACpD;YACF;QACF;QAEA,IAAIU,OAAON,kBAAkB;YAC3B,MAAMnE,UAAUkE,aAAa,CAAC;gBAC5BnB,SAAS,CAAC,QAAQ,EAAEI,OAAO,wDAAwD,EAAEgB,iBAAiB,eAAe,CAAC;gBACtHI,MAAM;oBACJC,kBACE,OAAOT,aAAa,cAAc,cAAcA;gBACpD;YACF;QACF;IACF;IAEA,OAAOb;AACT"}