@metamask/snaps-rpc-methods 5.0.0 → 7.0.0

package/dist/cjs/restricted/dialog.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/dialog.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 { DialogType, ComponentStruct, enumValue } from '@metamask/snaps-sdk';\nimport type { DialogParams, EnumToUnion, Component } from '@metamask/snaps-sdk';\nimport { validateComponentLinks } from '@metamask/snaps-utils';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport type { Infer, Struct } from 'superstruct';\nimport {\n  create,\n  enums,\n  object,\n  optional,\n  size,\n  string,\n  StructError,\n  type,\n  union,\n} from 'superstruct';\n\nimport { type MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_dialog';\n\nconst PlaceholderStruct = optional(size(string(), 1, 40));\n\nexport type Placeholder = Infer<typeof PlaceholderStruct>;\n\ntype ShowDialog = (\n  snapId: string,\n  type: EnumToUnion<DialogType>,\n  content: Component,\n  placeholder?: Placeholder,\n) => Promise<null | boolean | string>;\n\ntype MaybeUpdatePhisingList = () => Promise<void>;\ntype IsOnPhishingList = (url: string) => boolean;\n\nexport type DialogMethodHooks = {\n  /**\n   * @param snapId - The ID of the Snap that created the alert.\n   * @param type - The dialog type.\n   * @param content - The dialog custom UI.\n   * @param placeholder - The placeholder for the Prompt dialog input.\n   */\n  showDialog: ShowDialog;\n\n  maybeUpdatePhishingList: MaybeUpdatePhisingList;\n\n  /**\n   * @param url - The URL to check against the phishing list.\n   */\n  isOnPhishingList: IsOnPhishingList;\n};\n\ntype DialogSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: DialogMethodHooks;\n};\n\ntype DialogSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getDialogImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_dialog` permission. `snap_dialog`\n * lets the Snap display one of the following dialogs to the user:\n * - An alert, for displaying information.\n * - A confirmation, for accepting or rejecting some action.\n * - A prompt, for inputting some information.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the\n * permission.\n * @param options.methodHooks - The RPC method hooks needed by the method\n * implementation.\n * @returns The specification for the `snap_dialog` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  DialogSpecificationBuilderOptions,\n  DialogSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: DialogSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getDialogImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<DialogMethodHooks> = {\n  showDialog: true,\n  isOnPhishingList: true,\n  maybeUpdatePhishingList: true,\n};\n\nexport const dialogBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n// Note: We use `type` here instead of `object` because `type` does not validate\n// the keys of the object, which is what we want.\nconst BaseParamsStruct = type({\n  type: enums([DialogType.Alert, DialogType.Confirmation, DialogType.Prompt]),\n});\n\nconst AlertParametersStruct = object({\n  type: enumValue(DialogType.Alert),\n  content: ComponentStruct,\n});\n\nconst ConfirmationParametersStruct = object({\n  type: enumValue(DialogType.Confirmation),\n  content: ComponentStruct,\n});\n\nconst PromptParametersStruct = object({\n  type: enumValue(DialogType.Prompt),\n  content: ComponentStruct,\n  placeholder: PlaceholderStruct,\n});\n\nconst DialogParametersStruct = union([\n  AlertParametersStruct,\n  ConfirmationParametersStruct,\n  PromptParametersStruct,\n]);\n\nexport type DialogParameters = InferMatching<\n  typeof DialogParametersStruct,\n  DialogParams\n>;\n\nconst structs = {\n  [DialogType.Alert]: AlertParametersStruct,\n  [DialogType.Confirmation]: ConfirmationParametersStruct,\n  [DialogType.Prompt]: PromptParametersStruct,\n};\n\n/**\n * Builds the method implementation for `snap_dialog`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.showDialog - A function that shows the specified dialog in the\n * MetaMask UI and returns the appropriate value for the dialog type.\n * @param hooks.isOnPhishingList - A function that checks a link against the\n * phishing list and return true if it's in, otherwise false.\n * @param hooks.maybeUpdatePhishingList - A function that updates the phishing list if needed.\n * @returns The method implementation which return value depends on the dialog\n * type, valid return types are: string, boolean, null.\n */\nexport function getDialogImplementation({\n  showDialog,\n  isOnPhishingList,\n  maybeUpdatePhishingList,\n}: DialogMethodHooks) {\n  return async function dialogImplementation(\n    args: RestrictedMethodOptions<DialogParameters>,\n  ): Promise<boolean | null | string> {\n    const {\n      params,\n      context: { origin },\n    } = args;\n\n    const validatedType = getValidatedType(params);\n    const validatedParams = getValidatedParams(params, structs[validatedType]);\n\n    const { content } = validatedParams;\n\n    await maybeUpdatePhishingList();\n\n    validateComponentLinks(content, isOnPhishingList);\n\n    const placeholder =\n      validatedParams.type === DialogType.Prompt\n        ? validatedParams.placeholder\n        : undefined;\n\n    return showDialog(origin, validatedType, content, placeholder);\n  };\n}\n\n/**\n * Get the validated type of the dialog parameters. Throws an error if the type\n * is invalid.\n *\n * @param params - The parameters to validate.\n * @returns The validated type of the dialog parameters.\n */\nfunction getValidatedType(params: unknown): DialogType {\n  try {\n    return create(params, BaseParamsStruct).type;\n  } catch (error) {\n    throw rpcErrors.invalidParams({\n      message: `The \"type\" property must be one of: ${Object.values(\n        DialogType,\n      ).join(', ')}.`,\n    });\n  }\n}\n\n/**\n * Validates the confirm 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 struct - The struct to validate the params against.\n * @returns The validated confirm method parameter object.\n */\nfunction getValidatedParams(\n  params: unknown,\n  struct: Struct<any>,\n): DialogParameters {\n  try {\n    return create(params, struct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      const { key, type: errorType } = error;\n\n      if (key === 'placeholder' && errorType === 'never') {\n        throw rpcErrors.invalidParams({\n          message:\n            'Invalid params: Alerts or confirmations may not specify a \"placeholder\" field.',\n        });\n      }\n\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"names":["dialogBuilder","getDialogImplementation","methodName","PlaceholderStruct","optional","size","string","specificationBuilder","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","methodImplementation","subjectTypes","SubjectType","Snap","showDialog","isOnPhishingList","maybeUpdatePhishingList","Object","freeze","BaseParamsStruct","type","enums","DialogType","Alert","Confirmation","Prompt","AlertParametersStruct","object","enumValue","content","ComponentStruct","ConfirmationParametersStruct","PromptParametersStruct","placeholder","DialogParametersStruct","union","structs","dialogImplementation","args","params","context","origin","validatedType","getValidatedType","validatedParams","getValidatedParams","validateComponentLinks","undefined","create","error","rpcErrors","invalidParams","message","values","join","struct","StructError","key","errorType","internal"],"mappings":";;;;;;;;;;;IA6GaA,aAAa;eAAbA;;IAyDGC,uBAAuB;eAAvBA;;;sCAjK4B;2BAClB;0BAC6B;4BAEhB;6BAchC;AAIP,MAAMC,aAAa;AAEnB,MAAMC,oBAAoBC,IAAAA,qBAAQ,EAACC,IAAAA,iBAAI,EAACC,IAAAA,mBAAM,KAAI,GAAG;AA2CrD;;;;;;;;;;;;;CAaC,GACD,MAAMC,uBAIF,CAAC,EACHC,iBAAiB,IAAI,EACrBC,WAAW,EACuB;IAClC,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CC,YAAYX;QACZM;QACAM,sBAAsBb,wBAAwBQ;QAC9CM,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMR,cAAoD;IACxDS,YAAY;IACZC,kBAAkB;IAClBC,yBAAyB;AAC3B;AAEO,MAAMpB,gBAAgBqB,OAAOC,MAAM,CAAC;IACzCT,YAAYX;IACZK;IACAE;AACF;AAEA,gFAAgF;AAChF,iDAAiD;AACjD,MAAMc,mBAAmBC,IAAAA,iBAAI,EAAC;IAC5BA,MAAMC,IAAAA,kBAAK,EAAC;QAACC,oBAAU,CAACC,KAAK;QAAED,oBAAU,CAACE,YAAY;QAAEF,oBAAU,CAACG,MAAM;KAAC;AAC5E;AAEA,MAAMC,wBAAwBC,IAAAA,mBAAM,EAAC;IACnCP,MAAMQ,IAAAA,mBAAS,EAACN,oBAAU,CAACC,KAAK;IAChCM,SAASC,yBAAe;AAC1B;AAEA,MAAMC,+BAA+BJ,IAAAA,mBAAM,EAAC;IAC1CP,MAAMQ,IAAAA,mBAAS,EAACN,oBAAU,CAACE,YAAY;IACvCK,SAASC,yBAAe;AAC1B;AAEA,MAAME,yBAAyBL,IAAAA,mBAAM,EAAC;IACpCP,MAAMQ,IAAAA,mBAAS,EAACN,oBAAU,CAACG,MAAM;IACjCI,SAASC,yBAAe;IACxBG,aAAalC;AACf;AAEA,MAAMmC,yBAAyBC,IAAAA,kBAAK,EAAC;IACnCT;IACAK;IACAC;CACD;AAOD,MAAMI,UAAU;IACd,CAACd,oBAAU,CAACC,KAAK,CAAC,EAAEG;IACpB,CAACJ,oBAAU,CAACE,YAAY,CAAC,EAAEO;IAC3B,CAACT,oBAAU,CAACG,MAAM,CAAC,EAAEO;AACvB;AAcO,SAASnC,wBAAwB,EACtCiB,UAAU,EACVC,gBAAgB,EAChBC,uBAAuB,EACL;IAClB,OAAO,eAAeqB,qBACpBC,IAA+C;QAE/C,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGH;QAEJ,MAAMI,gBAAgBC,iBAAiBJ;QACvC,MAAMK,kBAAkBC,mBAAmBN,QAAQH,OAAO,CAACM,cAAc;QAEzE,MAAM,EAAEb,OAAO,EAAE,GAAGe;QAEpB,MAAM5B;QAEN8B,IAAAA,kCAAsB,EAACjB,SAASd;QAEhC,MAAMkB,cACJW,gBAAgBxB,IAAI,KAAKE,oBAAU,CAACG,MAAM,GACtCmB,gBAAgBX,WAAW,GAC3Bc;QAEN,OAAOjC,WAAW2B,QAAQC,eAAeb,SAASI;IACpD;AACF;AAEA;;;;;;CAMC,GACD,SAASU,iBAAiBJ,MAAe;IACvC,IAAI;QACF,OAAOS,IAAAA,mBAAM,EAACT,QAAQpB,kBAAkBC,IAAI;IAC9C,EAAE,OAAO6B,OAAO;QACd,MAAMC,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS,CAAC,oCAAoC,EAAEnC,OAAOoC,MAAM,CAC3D/B,oBAAU,EACVgC,IAAI,CAAC,MAAM,CAAC,CAAC;QACjB;IACF;AACF;AAEA;;;;;;;CAOC,GACD,SAAST,mBACPN,MAAe,EACfgB,MAAmB;IAEnB,IAAI;QACF,OAAOP,IAAAA,mBAAM,EAACT,QAAQgB;IACxB,EAAE,OAAON,OAAO;QACd,IAAIA,iBAAiBO,wBAAW,EAAE;YAChC,MAAM,EAAEC,GAAG,EAAErC,MAAMsC,SAAS,EAAE,GAAGT;YAEjC,IAAIQ,QAAQ,iBAAiBC,cAAc,SAAS;gBAClD,MAAMR,oBAAS,CAACC,aAAa,CAAC;oBAC5BC,SACE;gBACJ;YACF;YAEA,MAAMF,oBAAS,CAACC,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gBAAgB,EAAEH,MAAMG,OAAO,CAAC,CAAC,CAAC;YAC9C;QACF;QAEA,wBAAwB,GACxB,MAAMF,oBAAS,CAACS,QAAQ;IAC1B;AACF"}

package/dist/cjs/restricted/getBip32Entropy.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getBip32EntropyBuilder: function() {
-        return getBip32EntropyBuilder;
-    },
-    getBip32EntropyImplementation: function() {
-        return getBip32EntropyImplementation;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _utils1 = require("../utils");
-const targetName = 'snap_getBip32Entropy';
-/**
- * The specification builder for the `snap_getBip32Entropy` permission.
- * `snap_getBip32Entropy` lets the Snap control private keys for a particular
- * BIP-32 node.
- *
- * @param options - The specification builder options.
- * @param options.methodHooks - The RPC method hooks needed by the method implementation.
- * @returns The specification for the `snap_getBip32Entropy` permission.
- */ const specificationBuilder = ({ methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            _snapsutils.SnapCaveatType.PermittedDerivationPaths
-        ],
-        methodImplementation: getBip32EntropyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.PermittedDerivationPaths) {
-                throw _rpcerrors.rpcErrors.invalidParams({
-                    message: `Expected a single "${_snapsutils.SnapCaveatType.PermittedDerivationPaths}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-const getBip32EntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-function getBip32EntropyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip32Entropy(args) {
-        await getUnlockPromise(true);
-        const { params } = args;
-        (0, _utils.assert)(params);
-        const node = await (0, _utils1.getNode)({
-            curve: params.curve,
-            path: params.path,
-            secretRecoveryPhrase: await getMnemonic()
-        });
-        return node.toJSON();
-    };
-}
-
-//# sourceMappingURL=getBip32Entropy.js.map

package/dist/cjs/restricted/getBip32Entropy.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/getBip32Entropy.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  GetBip32EntropyParams,\n  GetBip32EntropyResult,\n} from '@metamask/snaps-sdk';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assert } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { getNode } from '../utils';\n\nconst targetName = 'snap_getBip32Entropy';\n\nexport type GetBip32EntropyMethodHooks = {\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\ntype GetBip32EntropySpecificationBuilderOptions = {\n  methodHooks: GetBip32EntropyMethodHooks;\n};\n\ntype GetBip32EntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip32EntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * The specification builder for the `snap_getBip32Entropy` permission.\n * `snap_getBip32Entropy` lets the Snap control private keys for a particular\n * BIP-32 node.\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 `snap_getBip32Entropy` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip32EntropySpecificationBuilderOptions,\n  GetBip32EntropySpecification\n> = ({ methodHooks }: GetBip32EntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],\n    methodImplementation: getBip32EntropyImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (\n        caveats?.length !== 1 ||\n        caveats[0].type !== SnapCaveatType.PermittedDerivationPaths\n      ) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.PermittedDerivationPaths}\" caveat.`,\n        });\n      }\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetBip32EntropyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip32EntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip32Entropy`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask extension is unlocked\n * and prompts the user to unlock their MetaMask if it is locked.\n * @returns The method implementation which returns a `JsonSLIP10Node`.\n * @throws If the params are invalid.\n */\nexport function getBip32EntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip32EntropyMethodHooks) {\n  return async function getBip32Entropy(\n    args: RestrictedMethodOptions<GetBip32EntropyParams>,\n  ): Promise<GetBip32EntropyResult> {\n    await getUnlockPromise(true);\n\n    const { params } = args;\n    assert(params);\n\n    const node = await getNode({\n      curve: params.curve,\n      path: params.path,\n      secretRecoveryPhrase: await getMnemonic(),\n    });\n\n    return node.toJSON();\n  };\n}\n"],"names":["getBip32EntropyBuilder","getBip32EntropyImplementation","targetName","specificationBuilder","methodHooks","permissionType","PermissionType","RestrictedMethod","allowedCaveats","SnapCaveatType","PermittedDerivationPaths","methodImplementation","validator","caveats","length","type","rpcErrors","invalidParams","message","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","Object","freeze","getBip32Entropy","args","params","assert","node","getNode","curve","path","secretRecoveryPhrase","toJSON"],"mappings":";;;;;;;;;;;IAqFaA,sBAAsB;eAAtBA;;IAgBGC,6BAA6B;eAA7BA;;;sCA/F4B;2BAClB;4BAKK;uBAER;wBAGC;AAExB,MAAMC,aAAa;AA4BnB;;;;;;;;CAQC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAA8C;IAC9D,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CL;QACAM,gBAAgB;YAACC,0BAAc,CAACC,wBAAwB;SAAC;QACzDC,sBAAsBV,8BAA8BG;QACpDQ,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKN,0BAAc,CAACC,wBAAwB,EAC3D;gBACA,MAAMM,oBAAS,CAACC,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAET,0BAAc,CAACC,wBAAwB,CAAC,SAAS,CAAC;gBACnF;YACF;QACF;QACAS,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMjB,cAA6D;IACjEkB,aAAa;IACbC,kBAAkB;AACpB;AAEO,MAAMvB,yBAAyBwB,OAAOC,MAAM,CAAC;IAClDvB;IACAC;IACAC;AACF;AAYO,SAASH,8BAA8B,EAC5CqB,WAAW,EACXC,gBAAgB,EACW;IAC3B,OAAO,eAAeG,gBACpBC,IAAoD;QAEpD,MAAMJ,iBAAiB;QAEvB,MAAM,EAAEK,MAAM,EAAE,GAAGD;QACnBE,IAAAA,aAAM,EAACD;QAEP,MAAME,OAAO,MAAMC,IAAAA,eAAO,EAAC;YACzBC,OAAOJ,OAAOI,KAAK;YACnBC,MAAML,OAAOK,IAAI;YACjBC,sBAAsB,MAAMZ;QAC9B;QAEA,OAAOQ,KAAKK,MAAM;IACpB;AACF"}

package/dist/cjs/restricted/getBip32PublicKey.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    Bip32PublicKeyArgsStruct: function() {
-        return Bip32PublicKeyArgsStruct;
-    },
-    getBip32PublicKeyBuilder: function() {
-        return getBip32PublicKeyBuilder;
-    },
-    getBip32PublicKeyImplementation: function() {
-        return getBip32PublicKeyImplementation;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-const _utils1 = require("../utils");
-const targetName = 'snap_getBip32PublicKey';
-const Bip32PublicKeyArgsStruct = (0, _snapsutils.bip32entropy)((0, _superstruct.object)({
-    path: _snapsutils.Bip32PathStruct,
-    curve: (0, _superstruct.enums)([
-        'ed25519',
-        'secp256k1'
-    ]),
-    compressed: (0, _superstruct.optional)((0, _superstruct.boolean)())
-}));
-/**
- * The specification builder for the `snap_getBip32PublicKey` permission.
- * `snap_getBip32PublicKey` lets the Snap retrieve public keys for a particular
- * BIP-32 node.
- *
- * @param options - The specification builder options.
- * @param options.methodHooks - The RPC method hooks needed by the method implementation.
- * @returns The specification for the `snap_getBip32PublicKey` permission.
- */ const specificationBuilder = ({ methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            _snapsutils.SnapCaveatType.PermittedDerivationPaths
-        ],
-        methodImplementation: getBip32PublicKeyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.PermittedDerivationPaths) {
-                throw _rpcerrors.rpcErrors.invalidParams({
-                    message: `Expected a single "${_snapsutils.SnapCaveatType.PermittedDerivationPaths}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-const getBip32PublicKeyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-function getBip32PublicKeyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip32PublicKey(args) {
-        await getUnlockPromise(true);
-        (0, _utils.assertStruct)(args.params, Bip32PublicKeyArgsStruct, 'Invalid BIP-32 public key params', _rpcerrors.rpcErrors.invalidParams);
-        const { params } = args;
-        const node = await (0, _utils1.getNode)({
-            curve: params.curve,
-            path: params.path,
-            secretRecoveryPhrase: await getMnemonic()
-        });
-        if (params.compressed) {
-            return node.compressedPublicKey;
-        }
-        return node.publicKey;
-    };
-}
-
-//# sourceMappingURL=getBip32PublicKey.js.map

package/dist/cjs/restricted/getBip44Entropy.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getBip44EntropyBuilder: function() {
-        return getBip44EntropyBuilder;
-    },
-    getBip44EntropyImplementation: function() {
-        return getBip44EntropyImplementation;
-    }
-});
-const _keytree = require("@metamask/key-tree");
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const targetName = 'snap_getBip44Entropy';
-/**
- * The specification builder for the `snap_getBip44Entropy` permission.
- * `snap_getBip44Entropy_*` lets the Snap control private keys for a particular
- * BIP-32 coin type.
- *
- * @param options - The specification builder options.
- * @param options.methodHooks - The RPC method hooks needed by the method
- * implementation.
- * @returns The specification for the `snap_getBip44Entropy` permission.
- */ const specificationBuilder = ({ methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            _snapsutils.SnapCaveatType.PermittedCoinTypes
-        ],
-        methodImplementation: getBip44EntropyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.PermittedCoinTypes) {
-                throw _rpcerrors.rpcErrors.invalidParams({
-                    message: `Expected a single "${_snapsutils.SnapCaveatType.PermittedCoinTypes}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-const getBip44EntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-function getBip44EntropyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip44Entropy(args) {
-        await getUnlockPromise(true);
-        // `args.params` is validated by the decorator, so it's safe to assert here.
-        const params = args.params;
-        const node = await _keytree.BIP44CoinTypeNode.fromDerivationPath([
-            await getMnemonic(),
-            `bip32:44'`,
-            `bip32:${params.coinType}'`
-        ]);
-        return node.toJSON();
-    };
-}
-
-//# sourceMappingURL=getBip44Entropy.js.map

package/dist/cjs/restricted/getBip44Entropy.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/getBip44Entropy.ts"],"sourcesContent":["import { BIP44CoinTypeNode } from '@metamask/key-tree';\nimport type {\n  PermissionSpecificationBuilder,\n  PermissionValidatorConstraint,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  GetBip44EntropyParams,\n  GetBip44EntropyResult,\n} from '@metamask/snaps-sdk';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst targetName = 'snap_getBip44Entropy';\n\nexport type GetBip44EntropyMethodHooks = {\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\ntype GetBip44EntropySpecificationBuilderOptions = {\n  methodHooks: GetBip44EntropyMethodHooks;\n};\n\ntype GetBip44EntropySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip44EntropyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * The specification builder for the `snap_getBip44Entropy` permission.\n * `snap_getBip44Entropy_*` lets the Snap control private keys for a particular\n * BIP-32 coin type.\n *\n * @param options - The specification builder options.\n * @param options.methodHooks - The RPC method hooks needed by the method\n * implementation.\n * @returns The specification for the `snap_getBip44Entropy` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip44EntropySpecificationBuilderOptions,\n  GetBip44EntropySpecification\n> = ({ methodHooks }: GetBip44EntropySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedCoinTypes],\n    methodImplementation: getBip44EntropyImplementation(methodHooks),\n    validator: ({ caveats }) => {\n      if (\n        caveats?.length !== 1 ||\n        caveats[0].type !== SnapCaveatType.PermittedCoinTypes\n      ) {\n        throw rpcErrors.invalidParams({\n          message: `Expected a single \"${SnapCaveatType.PermittedCoinTypes}\" caveat.`,\n        });\n      }\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetBip44EntropyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip44EntropyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip44Entropy`.\n *\n * @param hooks - The RPC method hooks.\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 * @returns The method implementation which returns a `BIP44CoinTypeNode`.\n * @throws If the params are invalid.\n */\nexport function getBip44EntropyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip44EntropyMethodHooks) {\n  return async function getBip44Entropy(\n    args: RestrictedMethodOptions<GetBip44EntropyParams>,\n  ): Promise<GetBip44EntropyResult> {\n    await getUnlockPromise(true);\n\n    // `args.params` is validated by the decorator, so it's safe to assert here.\n    const params = args.params as GetBip44EntropyParams;\n\n    const node = await BIP44CoinTypeNode.fromDerivationPath([\n      await getMnemonic(),\n      `bip32:44'`,\n      `bip32:${params.coinType}'`,\n    ]);\n\n    return node.toJSON();\n  };\n}\n"],"names":["getBip44EntropyBuilder","getBip44EntropyImplementation","targetName","specificationBuilder","methodHooks","permissionType","PermissionType","RestrictedMethod","allowedCaveats","SnapCaveatType","PermittedCoinTypes","methodImplementation","validator","caveats","length","type","rpcErrors","invalidParams","message","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","Object","freeze","getBip44Entropy","args","params","node","BIP44CoinTypeNode","fromDerivationPath","coinType","toJSON"],"mappings":";;;;;;;;;;;IAqFaA,sBAAsB;eAAtBA;;IAkBGC,6BAA6B;eAA7BA;;;yBAvGkB;sCAOU;2BAClB;4BAKK;AAK/B,MAAMC,aAAa;AA4BnB;;;;;;;;;CASC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAA8C;IAC9D,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CL;QACAM,gBAAgB;YAACC,0BAAc,CAACC,kBAAkB;SAAC;QACnDC,sBAAsBV,8BAA8BG;QACpDQ,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKN,0BAAc,CAACC,kBAAkB,EACrD;gBACA,MAAMM,oBAAS,CAACC,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAET,0BAAc,CAACC,kBAAkB,CAAC,SAAS,CAAC;gBAC7E;YACF;QACF;QACAS,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMjB,cAA6D;IACjEkB,aAAa;IACbC,kBAAkB;AACpB;AAEO,MAAMvB,yBAAyBwB,OAAOC,MAAM,CAAC;IAClDvB;IACAC;IACAC;AACF;AAcO,SAASH,8BAA8B,EAC5CqB,WAAW,EACXC,gBAAgB,EACW;IAC3B,OAAO,eAAeG,gBACpBC,IAAoD;QAEpD,MAAMJ,iBAAiB;QAEvB,4EAA4E;QAC5E,MAAMK,SAASD,KAAKC,MAAM;QAE1B,MAAMC,OAAO,MAAMC,0BAAiB,CAACC,kBAAkB,CAAC;YACtD,MAAMT;YACN,CAAC,SAAS,CAAC;YACX,CAAC,MAAM,EAAEM,OAAOI,QAAQ,CAAC,CAAC,CAAC;SAC5B;QAED,OAAOH,KAAKI,MAAM;IACpB;AACF"}

package/dist/cjs/restricted/getEntropy.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    GetEntropyArgsStruct: function() {
-        return GetEntropyArgsStruct;
-    },
-    getEntropyBuilder: function() {
-        return getEntropyBuilder;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-const _utils1 = require("../utils");
-const targetName = 'snap_getEntropy';
-const GetEntropyArgsStruct = (0, _superstruct.object)({
-    version: (0, _superstruct.literal)(1),
-    salt: (0, _superstruct.optional)((0, _superstruct.string)())
-});
-const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats,
-        methodImplementation: getEntropyImplementation(methodHooks),
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-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;
-        (0, _utils.assertStruct)(params, GetEntropyArgsStruct, 'Invalid "snap_getEntropy" parameters', _rpcerrors.rpcErrors.invalidParams);
-        await getUnlockPromise(true);
-        const mnemonicPhrase = await getMnemonic();
-        return (0, _utils1.deriveEntropy)({
-            input: origin,
-            salt: params.salt,
-            mnemonicPhrase,
-            magic: _snapsutils.SIP_6_MAGIC_VALUE
-        });
-    };
-}
-
-//# sourceMappingURL=getEntropy.js.map

package/dist/cjs/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":["GetEntropyArgsStruct","getEntropyBuilder","targetName","object","version","literal","salt","optional","string","specificationBuilder","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","methodImplementation","getEntropyImplementation","subjectTypes","SubjectType","Snap","getMnemonic","getUnlockPromise","Object","freeze","getEntropy","options","params","context","origin","assertStruct","rpcErrors","invalidParams","mnemonicPhrase","deriveEntropy","input","magic","SIP_6_MAGIC_VALUE"],"mappings":";;;;;;;;;;;IA+BaA,oBAAoB;eAApBA;;IAmCAC,iBAAiB;eAAjBA;;;sCA7D+B;2BAClB;4BAEQ;uBAEL;6BAEqB;wBAGpB;AAE9B,MAAMC,aAAa;AAcZ,MAAMF,uBAAuBG,IAAAA,mBAAM,EAAC;IACzCC,SAASC,IAAAA,oBAAO,EAAC;IACjBC,MAAMC,IAAAA,qBAAQ,EAACC,IAAAA,mBAAM;AACvB;AAUA,MAAMC,uBAIF,CAAC,EACHC,iBAAiB,IAAI,EACrBC,WAAW,EAC2B;IACtC,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CZ;QACAQ;QACAK,sBAAsBC,yBAAyBL;QAC/CM,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMR,cAAkD;IACtDS,aAAa;IACbC,kBAAkB;AACpB;AAEO,MAAMpB,oBAAoBqB,OAAOC,MAAM,CAAC;IAC7CrB;IACAO;IACAE;AACF;AAgBA;;;;;;;;;;;CAWC,GACD,SAASK,yBAAyB,EAChCI,WAAW,EACXC,gBAAgB,EACA;IAChB,OAAO,eAAeG,WACpBC,OAAkD;QAElD,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGH;QAEJI,IAAAA,mBAAY,EACVH,QACA1B,sBACA,wCACA8B,oBAAS,CAACC,aAAa;QAGzB,MAAMV,iBAAiB;QACvB,MAAMW,iBAAiB,MAAMZ;QAE7B,OAAOa,IAAAA,qBAAa,EAAC;YACnBC,OAAON;YACPtB,MAAMoB,OAAOpB,IAAI;YACjB0B;YACAG,OAAOC,6BAAiB;QAC1B;IACF;AACF"}

package/dist/cjs/restricted/getLocale.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    specificationBuilder: function() {
-        return specificationBuilder;
-    },
-    getLocaleBuilder: function() {
-        return getLocaleBuilder;
-    },
-    getImplementation: function() {
-        return getImplementation;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const methodName = 'snap_getLocale';
-const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: getImplementation(methodHooks),
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getLocale: true
-};
-const getLocaleBuilder = Object.freeze({
-    targetName: methodName,
-    specificationBuilder,
-    methodHooks
-});
-function getImplementation({ getLocale }) {
-    return async function implementation(_args) {
-        return getLocale();
-    };
-}
-
-//# sourceMappingURL=getLocale.js.map

package/dist/cjs/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":["specificationBuilder","getLocaleBuilder","getImplementation","methodName","allowedCaveats","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","methodImplementation","subjectTypes","SubjectType","Snap","getLocale","Object","freeze","implementation","_args"],"mappings":";;;;;;;;;;;IAuCaA,oBAAoB;eAApBA;;IAkBAC,gBAAgB;eAAhBA;;IAaGC,iBAAiB;eAAjBA;;;sCAhE4B;AAM5C,MAAMC,aAAa;AA2BZ,MAAMH,uBAIT,CAAC,EAAEI,iBAAiB,IAAI,EAAEC,WAAW,EAA+B;IACtE,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CC,YAAYN;QACZC;QACAM,sBAAsBR,kBAAkBG;QACxCM,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEA,MAAMR,cAAuD;IAC3DS,WAAW;AACb;AAEO,MAAMb,mBAAmBc,OAAOC,MAAM,CAAC;IAC5CP,YAAYN;IACZH;IACAK;AACF;AASO,SAASH,kBAAkB,EAAEY,SAAS,EAAwB;IACnE,OAAO,eAAeG,eACpBC,KAA0D;QAE1D,OAAOJ;IACT;AACF"}

package/dist/cjs/restricted/index.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    WALLET_SNAP_PERMISSION_KEY: function() {
-        return _invokeSnap.WALLET_SNAP_PERMISSION_KEY;
-    },
-    getEncryptionKey: function() {
-        return _manageState.getEncryptionKey;
-    },
-    restrictedMethodPermissionBuilders: function() {
-        return restrictedMethodPermissionBuilders;
-    }
-});
-const _dialog = require("./dialog");
-const _getBip32Entropy = require("./getBip32Entropy");
-const _getBip32PublicKey = require("./getBip32PublicKey");
-const _getBip44Entropy = require("./getBip44Entropy");
-const _getEntropy = require("./getEntropy");
-const _getLocale = require("./getLocale");
-const _invokeSnap = require("./invokeSnap");
-const _manageAccounts = require("./manageAccounts");
-const _manageState = require("./manageState");
-const _notify = require("./notify");
-_export_star(require("./caveats"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-const restrictedMethodPermissionBuilders = {
-    [_dialog.dialogBuilder.targetName]: _dialog.dialogBuilder,
-    [_getBip32Entropy.getBip32EntropyBuilder.targetName]: _getBip32Entropy.getBip32EntropyBuilder,
-    [_getBip32PublicKey.getBip32PublicKeyBuilder.targetName]: _getBip32PublicKey.getBip32PublicKeyBuilder,
-    [_getBip44Entropy.getBip44EntropyBuilder.targetName]: _getBip44Entropy.getBip44EntropyBuilder,
-    [_getEntropy.getEntropyBuilder.targetName]: _getEntropy.getEntropyBuilder,
-    [_invokeSnap.invokeSnapBuilder.targetName]: _invokeSnap.invokeSnapBuilder,
-    [_manageState.manageStateBuilder.targetName]: _manageState.manageStateBuilder,
-    [_notify.notifyBuilder.targetName]: _notify.notifyBuilder,
-    [_manageAccounts.manageAccountsBuilder.targetName]: _manageAccounts.manageAccountsBuilder,
-    [_getLocale.getLocaleBuilder.targetName]: _getLocale.getLocaleBuilder
-};
-
-//# sourceMappingURL=index.js.map

package/dist/cjs/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":["WALLET_SNAP_PERMISSION_KEY","getEncryptionKey","restrictedMethodPermissionBuilders","dialogBuilder","targetName","getBip32EntropyBuilder","getBip32PublicKeyBuilder","getBip44EntropyBuilder","getEntropyBuilder","invokeSnapBuilder","manageStateBuilder","notifyBuilder","manageAccountsBuilder","getLocaleBuilder"],"mappings":";;;;;;;;;;;IAqBSA,0BAA0B;eAA1BA,sCAA0B;;IAC1BC,gBAAgB;eAAhBA,6BAAgB;;IAaZC,kCAAkC;eAAlCA;;;wBAlCiB;iCAES;mCAEE;iCAEF;4BAEL;2BAED;4BAEC;gCAEI;6BAEH;wBAEL;qBA6BhB;;;;;;;;;;;;;;AAbP,MAAMA,qCAAqC;IAChD,CAACC,qBAAa,CAACC,UAAU,CAAC,EAAED,qBAAa;IACzC,CAACE,uCAAsB,CAACD,UAAU,CAAC,EAAEC,uCAAsB;IAC3D,CAACC,2CAAwB,CAACF,UAAU,CAAC,EAAEE,2CAAwB;IAC/D,CAACC,uCAAsB,CAACH,UAAU,CAAC,EAAEG,uCAAsB;IAC3D,CAACC,6BAAiB,CAACJ,UAAU,CAAC,EAAEI,6BAAiB;IACjD,CAACC,6BAAiB,CAACL,UAAU,CAAC,EAAEK,6BAAiB;IACjD,CAACC,+BAAkB,CAACN,UAAU,CAAC,EAAEM,+BAAkB;IACnD,CAACC,qBAAa,CAACP,UAAU,CAAC,EAAEO,qBAAa;IACzC,CAACC,qCAAqB,CAACR,UAAU,CAAC,EAAEQ,qCAAqB;IACzD,CAACC,2BAAgB,CAACT,UAAU,CAAC,EAAES,2BAAgB;AACjD"}

package/dist/cjs/restricted/invokeSnap.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    WALLET_SNAP_PERMISSION_KEY: function() {
-        return WALLET_SNAP_PERMISSION_KEY;
-    },
-    handleSnapInstall: function() {
-        return handleSnapInstall;
-    },
-    invokeSnapBuilder: function() {
-        return invokeSnapBuilder;
-    },
-    getInvokeSnapImplementation: function() {
-        return getInvokeSnapImplementation;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';
-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: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName: WALLET_SNAP_PERMISSION_KEY,
-        allowedCaveats: [
-            _snapsutils.SnapCaveatType.SnapIds
-        ],
-        methodImplementation: getInvokeSnapImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== _snapsutils.SnapCaveatType.SnapIds) {
-                throw _rpcerrors.rpcErrors.invalidParams({
-                    message: `Expected a single "${_snapsutils.SnapCaveatType.SnapIds}" caveat.`
-                });
-            }
-        },
-        sideEffect: {
-            onPermitted: handleSnapInstall
-        }
-    };
-};
-const methodHooks = {
-    getSnap: true,
-    handleSnapRpcRequest: true
-};
-const invokeSnapBuilder = Object.freeze({
-    targetName: WALLET_SNAP_PERMISSION_KEY,
-    specificationBuilder,
-    methodHooks
-});
-function getInvokeSnapImplementation({ getSnap, handleSnapRpcRequest }) {
-    return async function invokeSnap(options) {
-        const { params = {}, context } = options;
-        const { snapId, request } = params;
-        if (!getSnap(snapId)) {
-            throw _rpcerrors.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: _snapsutils.HandlerType.OnRpcRequest
-        });
-    };
-}
-
-//# sourceMappingURL=invokeSnap.js.map

package/dist/cjs/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":["WALLET_SNAP_PERMISSION_KEY","handleSnapInstall","invokeSnapBuilder","getInvokeSnapImplementation","requestData","messagingSystem","snaps","permissions","caveats","value","permittedSnaps","call","metadata","origin","dedupedSnaps","Object","keys","reduce","filteredSnaps","snap","specificationBuilder","methodHooks","permissionType","PermissionType","RestrictedMethod","targetName","allowedCaveats","SnapCaveatType","SnapIds","methodImplementation","validator","length","type","rpcErrors","invalidParams","message","sideEffect","onPermitted","getSnap","handleSnapRpcRequest","freeze","invokeSnap","options","params","context","snapId","request","invalidRequest","handler","HandlerType","OnRpcRequest"],"mappings":";;;;;;;;;;;IAoBaA,0BAA0B;eAA1BA;;IAwDAC,iBAAiB;eAAjBA;;IAoEAC,iBAAiB;eAAjBA;;IAeGC,2BAA2B;eAA3BA;;;sCAxJe;2BACL;4BAOkB;AAKrC,MAAMH,6BAA6B;AAwDnC,MAAMC,oBAGM,OAAO,EAAEG,WAAW,EAAEC,eAAe,EAAE;IACxD,MAAMC,QAAQF,YAAYG,WAAW,CAACP,2BAA2B,CAACQ,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;AACA;;;;;;;;;;;CAWC,GACD,MAAMM,uBAIF,CAAC,EAAEC,WAAW,EAAyC;IACzD,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,gBAAgB;QAC/CC,YAAYzB;QACZ0B,gBAAgB;YAACC,0BAAc,CAACC,OAAO;SAAC;QACxCC,sBAAsB1B,4BAA4BkB;QAClDS,WAAW,CAAC,EAAEtB,OAAO,EAAE;YACrB,IAAIA,SAASuB,WAAW,KAAKvB,OAAO,CAAC,EAAE,CAACwB,IAAI,KAAKL,0BAAc,CAACC,OAAO,EAAE;gBACvE,MAAMK,oBAAS,CAACC,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAER,0BAAc,CAACC,OAAO,CAAC,SAAS,CAAC;gBAClE;YACF;QACF;QACAQ,YAAY;YACVC,aAAapC;QACf;IACF;AACF;AAEA,MAAMoB,cAAwD;IAC5DiB,SAAS;IACTC,sBAAsB;AACxB;AAEO,MAAMrC,oBAAoBa,OAAOyB,MAAM,CAAC;IAC7Cf,YAAYzB;IACZoB;IACAC;AACF;AAWO,SAASlB,4BAA4B,EAC1CmC,OAAO,EACPC,oBAAoB,EACE;IACtB,OAAO,eAAeE,WACpBC,OAAkD;QAElD,MAAM,EAAEC,SAAS,CAAC,CAAC,EAAEC,OAAO,EAAE,GAAGF;QAEjC,MAAM,EAAEG,MAAM,EAAEC,OAAO,EAAE,GAAGH;QAE5B,IAAI,CAACL,QAAQO,SAAS;YACpB,MAAMZ,oBAAS,CAACc,cAAc,CAAC;gBAC7BZ,SAAS,CAAC,UAAU,EAAEU,OAAO,sEAAsE,CAAC;YACtG;QACF;QAEA,MAAM,EAAEhC,MAAM,EAAE,GAAG+B;QAEnB,OAAQ,MAAML,qBAAqB;YACjCM;YACAhC;YACAiC;YACAE,SAASC,uBAAW,CAACC,YAAY;QACnC;IACF;AACF"}