@metamask/snaps-rpc-methods 6.0.0 → 7.0.0

package/dist/esm/restricted/caveats/permittedCoinTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/restricted/caveats/permittedCoinTypes.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  RestrictedMethodCaveatSpecificationConstraint,\n  Caveat,\n} from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport type { GetBip44EntropyParams } from '@metamask/snaps-sdk';\nimport { FORBIDDEN_COIN_TYPES, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, isPlainObject } from '@metamask/utils';\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function permittedCoinTypesCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.PermittedCoinTypes,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validate the params for `snap_getBip44Entropy`.\n *\n * @param value - The params to validate.\n * @throws If the params are invalid.\n */\nexport function validateBIP44Params(\n  value: unknown,\n): asserts value is GetBip44EntropyParams {\n  if (!isPlainObject(value) || !hasProperty(value, 'coinType')) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object containing a coin type.',\n    });\n  }\n\n  if (\n    typeof value.coinType !== 'number' ||\n    !Number.isInteger(value.coinType) ||\n    value.coinType < 0 ||\n    value.coinType > 0x7fffffff\n  ) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Invalid \"coinType\" parameter. Coin type must be a non-negative integer.',\n    });\n  }\n\n  if (FORBIDDEN_COIN_TYPES.includes(value.coinType)) {\n    throw rpcErrors.invalidParams({\n      message: `Coin type ${value.coinType} is forbidden.`,\n    });\n  }\n}\n\n/**\n * Validate the coin types values associated with a caveat. This checks if the\n * values are non-negative integers (>= 0).\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat is invalid.\n */\nexport function validateBIP44Caveat(caveat: Caveat<string, any>) {\n  if (\n    !hasProperty(caveat, 'value') ||\n    !Array.isArray(caveat.value) ||\n    caveat.value.length === 0\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected non-empty array of coin types.',\n    });\n  }\n\n  caveat.value.forEach(validateBIP44Params);\n}\n\nexport const PermittedCoinTypesCaveatSpecification: Record<\n  SnapCaveatType.PermittedCoinTypes,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.PermittedCoinTypes]: Object.freeze({\n    type: SnapCaveatType.PermittedCoinTypes,\n    decorator: (\n      method,\n      caveat: Caveat<\n        SnapCaveatType.PermittedCoinTypes,\n        GetBip44EntropyParams[]\n      >,\n    ) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP44Params(params);\n\n        const coinType = caveat.value.find(\n          (caveatValue) => caveatValue.coinType === params.coinType,\n        );\n\n        if (!coinType) {\n          throw providerErrors.unauthorized({\n            message:\n              'The requested coin type is not permitted. Allowed coin types must be specified in the snap manifest.',\n          });\n        }\n\n        return await method(args);\n      };\n    },\n    validator: (caveat) => validateBIP44Caveat(caveat),\n  }),\n};\n"],"names":["providerErrors","rpcErrors","FORBIDDEN_COIN_TYPES","SnapCaveatType","hasProperty","isPlainObject","permittedCoinTypesCaveatMapper","value","caveats","type","PermittedCoinTypes","validateBIP44Params","invalidParams","message","coinType","Number","isInteger","includes","validateBIP44Caveat","caveat","Array","isArray","length","forEach","PermittedCoinTypesCaveatSpecification","Object","freeze","decorator","method","args","params","find","caveatValue","unauthorized","validator"],"mappings":"AAKA,SAASA,cAAc,EAAEC,SAAS,QAAQ,uBAAuB;AAEjE,SAASC,oBAAoB,EAAEC,cAAc,QAAQ,wBAAwB;AAE7E,SAASC,WAAW,EAAEC,aAAa,QAAQ,kBAAkB;AAE7D;;;;;;;CAOC,GACD,OAAO,SAASC,+BACdC,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEC,MAAMN,eAAeO,kBAAkB;gBACvCH;YACF;SACD;IACH;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASI,oBACdJ,KAAc;IAEd,IAAI,CAACF,cAAcE,UAAU,CAACH,YAAYG,OAAO,aAAa;QAC5D,MAAMN,UAAUW,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,IACE,OAAON,MAAMO,QAAQ,KAAK,YAC1B,CAACC,OAAOC,SAAS,CAACT,MAAMO,QAAQ,KAChCP,MAAMO,QAAQ,GAAG,KACjBP,MAAMO,QAAQ,GAAG,YACjB;QACA,MAAMb,UAAUW,aAAa,CAAC;YAC5BC,SACE;QACJ;IACF;IAEA,IAAIX,qBAAqBe,QAAQ,CAACV,MAAMO,QAAQ,GAAG;QACjD,MAAMb,UAAUW,aAAa,CAAC;YAC5BC,SAAS,CAAC,UAAU,EAAEN,MAAMO,QAAQ,CAAC,cAAc,CAAC;QACtD;IACF;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASI,oBAAoBC,MAA2B;IAC7D,IACE,CAACf,YAAYe,QAAQ,YACrB,CAACC,MAAMC,OAAO,CAACF,OAAOZ,KAAK,KAC3BY,OAAOZ,KAAK,CAACe,MAAM,KAAK,GACxB;QACA,MAAMrB,UAAUW,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEAM,OAAOZ,KAAK,CAACgB,OAAO,CAACZ;AACvB;AAEA,OAAO,MAAMa,wCAGT;IACF,CAACrB,eAAeO,kBAAkB,CAAC,EAAEe,OAAOC,MAAM,CAAC;QACjDjB,MAAMN,eAAeO,kBAAkB;QACvCiB,WAAW,CACTC,QACAT;YAKA,OAAO,OAAOU;gBACZ,MAAM,EAAEC,MAAM,EAAE,GAAGD;gBACnBlB,oBAAoBmB;gBAEpB,MAAMhB,WAAWK,OAAOZ,KAAK,CAACwB,IAAI,CAChC,CAACC,cAAgBA,YAAYlB,QAAQ,KAAKgB,OAAOhB,QAAQ;gBAG3D,IAAI,CAACA,UAAU;oBACb,MAAMd,eAAeiC,YAAY,CAAC;wBAChCpB,SACE;oBACJ;gBACF;gBAEA,OAAO,MAAMe,OAAOC;YACtB;QACF;QACAK,WAAW,CAACf,SAAWD,oBAAoBC;IAC7C;AACF,EAAE"}

package/dist/esm/restricted/caveats/permittedDerivationPaths.js

@@ -1,64 +0,0 @@
-import { providerErrors, rpcErrors } from '@metamask/rpc-errors';
-import { SnapCaveatType, Bip32EntropyStruct, isEqual } from '@metamask/snaps-utils';
-import { assertStruct } from '@metamask/utils';
-import { array, size, type } from 'superstruct';
-/**
- * Map a raw value from the `initialPermissions` to a caveat specification.
- * Note that this function does not do any validation, that's handled by the
- * PermissionsController when the permission is requested.
- *
- * @param value - The raw value from the `initialPermissions`.
- * @returns The caveat specification.
- */ export function permittedDerivationPathsCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: SnapCaveatType.PermittedDerivationPaths,
-                value
-            }
-        ]
-    };
-}
-/**
- * Validate a caveat path object. The object must consist of a `path` array and
- * a `curve` string. Paths must start with `m`, and must contain at
- * least two indices. If `ed25519` is used, this checks if all the path indices
- * are hardened.
- *
- * @param value - The value to validate.
- * @throws If the value is invalid.
- */ export function validateBIP32Path(value) {
-    assertStruct(value, Bip32EntropyStruct, 'Invalid BIP-32 entropy path definition', rpcErrors.invalidParams);
-}
-/**
- * Validate the path values associated with a caveat. This validates that the
- * value is a non-empty array with valid derivation paths and curves.
- *
- * @param caveat - The caveat to validate.
- * @throws If the value is invalid.
- */ export function validateBIP32CaveatPaths(caveat) {
-    assertStruct(caveat, type({
-        value: size(array(Bip32EntropyStruct), 1, Infinity)
-    }), 'Invalid BIP-32 entropy caveat', rpcErrors.internal);
-}
-export const PermittedDerivationPathsCaveatSpecification = {
-    [SnapCaveatType.PermittedDerivationPaths]: Object.freeze({
-        type: SnapCaveatType.PermittedDerivationPaths,
-        decorator: (method, caveat)=>{
-            return async (args)=>{
-                const { params } = args;
-                validateBIP32Path(params);
-                const path = caveat.value.find((caveatPath)=>isEqual(params.path.slice(0, caveatPath.path.length), caveatPath.path) && caveatPath.curve === params.curve);
-                if (!path) {
-                    throw providerErrors.unauthorized({
-                        message: 'The requested path is not permitted. Allowed paths must be specified in the snap manifest.'
-                    });
-                }
-                return await method(args);
-            };
-        },
-        validator: (caveat)=>validateBIP32CaveatPaths(caveat)
-    })
-};
-
-//# sourceMappingURL=permittedDerivationPaths.js.map

package/dist/esm/restricted/caveats/permittedDerivationPaths.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/restricted/caveats/permittedDerivationPaths.ts"],"sourcesContent":["import type {\n  Caveat,\n  PermissionConstraint,\n  RestrictedMethodCaveatSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\nimport type { Bip32Entropy } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  Bip32EntropyStruct,\n  isEqual,\n} from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { array, size, type } from 'superstruct';\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function permittedDerivationPathsCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.PermittedDerivationPaths,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validate a caveat path object. The object must consist of a `path` array and\n * a `curve` string. Paths must start with `m`, and must contain at\n * least two indices. If `ed25519` is used, this checks if all the path indices\n * are hardened.\n *\n * @param value - The value to validate.\n * @throws If the value is invalid.\n */\nexport function validateBIP32Path(\n  value: unknown,\n): asserts value is Bip32Entropy {\n  assertStruct(\n    value,\n    Bip32EntropyStruct,\n    'Invalid BIP-32 entropy path definition',\n    rpcErrors.invalidParams,\n  );\n}\n\n/**\n * Validate the path values associated with a caveat. This validates that the\n * value is a non-empty array with valid derivation paths and curves.\n *\n * @param caveat - The caveat to validate.\n * @throws If the value is invalid.\n */\nexport function validateBIP32CaveatPaths(\n  caveat: Caveat<string, any>,\n): asserts caveat is Caveat<string, Bip32Entropy[]> {\n  assertStruct(\n    caveat,\n    type({ value: size(array(Bip32EntropyStruct), 1, Infinity) }),\n    'Invalid BIP-32 entropy caveat',\n    rpcErrors.internal,\n  );\n}\n\nexport const PermittedDerivationPathsCaveatSpecification: Record<\n  SnapCaveatType.PermittedDerivationPaths,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.PermittedDerivationPaths]: Object.freeze({\n    type: SnapCaveatType.PermittedDerivationPaths,\n    decorator: (\n      method,\n      caveat: Caveat<SnapCaveatType.PermittedDerivationPaths, Bip32Entropy[]>,\n    ) => {\n      return async (args) => {\n        const { params } = args;\n        validateBIP32Path(params);\n\n        const path = caveat.value.find(\n          (caveatPath) =>\n            isEqual(\n              params.path.slice(0, caveatPath.path.length),\n              caveatPath.path,\n            ) && caveatPath.curve === params.curve,\n        );\n\n        if (!path) {\n          throw providerErrors.unauthorized({\n            message:\n              'The requested path is not permitted. Allowed paths must be specified in the snap manifest.',\n          });\n        }\n\n        return await method(args);\n      };\n    },\n    validator: (caveat) => validateBIP32CaveatPaths(caveat),\n  }),\n};\n"],"names":["providerErrors","rpcErrors","SnapCaveatType","Bip32EntropyStruct","isEqual","assertStruct","array","size","type","permittedDerivationPathsCaveatMapper","value","caveats","PermittedDerivationPaths","validateBIP32Path","invalidParams","validateBIP32CaveatPaths","caveat","Infinity","internal","PermittedDerivationPathsCaveatSpecification","Object","freeze","decorator","method","args","params","path","find","caveatPath","slice","length","curve","unauthorized","message","validator"],"mappings":"AAKA,SAASA,cAAc,EAAEC,SAAS,QAAQ,uBAAuB;AAEjE,SACEC,cAAc,EACdC,kBAAkB,EAClBC,OAAO,QACF,wBAAwB;AAE/B,SAASC,YAAY,QAAQ,kBAAkB;AAC/C,SAASC,KAAK,EAAEC,IAAI,EAAEC,IAAI,QAAQ,cAAc;AAEhD;;;;;;;CAOC,GACD,OAAO,SAASC,qCACdC,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEH,MAAMN,eAAeU,wBAAwB;gBAC7CF;YACF;SACD;IACH;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASG,kBACdH,KAAc;IAEdL,aACEK,OACAP,oBACA,0CACAF,UAAUa,aAAa;AAE3B;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,yBACdC,MAA2B;IAE3BX,aACEW,QACAR,KAAK;QAAEE,OAAOH,KAAKD,MAAMH,qBAAqB,GAAGc;IAAU,IAC3D,iCACAhB,UAAUiB,QAAQ;AAEtB;AAEA,OAAO,MAAMC,8CAGT;IACF,CAACjB,eAAeU,wBAAwB,CAAC,EAAEQ,OAAOC,MAAM,CAAC;QACvDb,MAAMN,eAAeU,wBAAwB;QAC7CU,WAAW,CACTC,QACAP;YAEA,OAAO,OAAOQ;gBACZ,MAAM,EAAEC,MAAM,EAAE,GAAGD;gBACnBX,kBAAkBY;gBAElB,MAAMC,OAAOV,OAAON,KAAK,CAACiB,IAAI,CAC5B,CAACC,aACCxB,QACEqB,OAAOC,IAAI,CAACG,KAAK,CAAC,GAAGD,WAAWF,IAAI,CAACI,MAAM,GAC3CF,WAAWF,IAAI,KACZE,WAAWG,KAAK,KAAKN,OAAOM,KAAK;gBAG1C,IAAI,CAACL,MAAM;oBACT,MAAM1B,eAAegC,YAAY,CAAC;wBAChCC,SACE;oBACJ;gBACF;gBAEA,OAAO,MAAMV,OAAOC;YACtB;QACF;QACAU,WAAW,CAAClB,SAAWD,yBAAyBC;IAClD;AACF,EAAE"}

package/dist/esm/restricted/caveats/snapIds.js

@@ -1,50 +0,0 @@
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SnapCaveatType, SnapIdsStruct } from '@metamask/snaps-utils';
-import { hasProperty, assertStruct } from '@metamask/utils';
-import { type } from 'superstruct';
-/**
- * Map a raw value from the `initialPermissions` to a caveat specification.
- * Note that this function does not do any validation, that's handled by the
- * PermissionsController when the permission is requested.
- *
- * @param value - The raw value from the `initialPermissions`.
- * @returns The caveat specification.
- */ export function snapIdsCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: SnapCaveatType.SnapIds,
-                value
-            }
-        ]
-    };
-}
-/**
- * Validates that the caveat value exists and is a non-empty object.
- *
- * @param caveat - The caveat to validate.
- * @throws If the caveat is invalid.
- */ export function validateSnapIdsCaveat(caveat) {
-    assertStruct(caveat, type({
-        value: SnapIdsStruct
-    }), 'Expected caveat to have a value property of a non-empty object of snap IDs.', rpcErrors.invalidParams);
-}
-export const SnapIdsCaveatSpecification = {
-    [SnapCaveatType.SnapIds]: Object.freeze({
-        type: SnapCaveatType.SnapIds,
-        validator: (caveat)=>validateSnapIdsCaveat(caveat),
-        decorator: (method, caveat)=>{
-            return async (args)=>{
-                const { params, context: { origin } } = args;
-                const snapIds = caveat.value;
-                const { snapId } = params;
-                if (!hasProperty(snapIds, snapId)) {
-                    throw new Error(`${origin} does not have permission to invoke ${snapId} snap.`);
-                }
-                return await method(args);
-            };
-        }
-    })
-};
-
-//# sourceMappingURL=snapIds.js.map

package/dist/esm/restricted/caveats/snapIds.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/restricted/caveats/snapIds.ts"],"sourcesContent":["import type {\n  Caveat,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n  RestrictedMethodCaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { SnapIds } from '@metamask/snaps-utils';\nimport { SnapCaveatType, SnapIdsStruct } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\nimport { hasProperty, assertStruct } from '@metamask/utils';\nimport { type } from 'superstruct';\n\nimport type { InvokeSnapParams } from '../invokeSnap';\n\n/**\n * Map a raw value from the `initialPermissions` to a caveat specification.\n * Note that this function does not do any validation, that's handled by the\n * PermissionsController when the permission is requested.\n *\n * @param value - The raw value from the `initialPermissions`.\n * @returns The caveat specification.\n */\nexport function snapIdsCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapIds,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Validates that the caveat value exists and is a non-empty object.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat is invalid.\n */\nexport function validateSnapIdsCaveat(\n  caveat: Caveat<string, any>,\n): asserts caveat is Caveat<string, SnapIds> {\n  assertStruct(\n    caveat,\n    type({\n      value: SnapIdsStruct,\n    }),\n    'Expected caveat to have a value property of a non-empty object of snap IDs.',\n    rpcErrors.invalidParams,\n  );\n}\n\nexport const SnapIdsCaveatSpecification: Record<\n  SnapCaveatType.SnapIds,\n  RestrictedMethodCaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.SnapIds]: Object.freeze({\n    type: SnapCaveatType.SnapIds,\n    validator: (caveat) => validateSnapIdsCaveat(caveat),\n    decorator: (method, caveat) => {\n      return async (args) => {\n        const {\n          params,\n          context: { origin },\n        }: RestrictedMethodOptions<RestrictedMethodParameters> = args;\n        const snapIds = caveat.value;\n        const { snapId } = params as InvokeSnapParams;\n        if (!hasProperty(snapIds, snapId)) {\n          throw new Error(\n            `${origin} does not have permission to invoke ${snapId} snap.`,\n          );\n        }\n        return await method(args);\n      };\n    },\n  }),\n};\n"],"names":["rpcErrors","SnapCaveatType","SnapIdsStruct","hasProperty","assertStruct","type","snapIdsCaveatMapper","value","caveats","SnapIds","validateSnapIdsCaveat","caveat","invalidParams","SnapIdsCaveatSpecification","Object","freeze","validator","decorator","method","args","params","context","origin","snapIds","snapId","Error"],"mappings":"AAOA,SAASA,SAAS,QAAQ,uBAAuB;AAEjD,SAASC,cAAc,EAAEC,aAAa,QAAQ,wBAAwB;AAEtE,SAASC,WAAW,EAAEC,YAAY,QAAQ,kBAAkB;AAC5D,SAASC,IAAI,QAAQ,cAAc;AAInC;;;;;;;CAOC,GACD,OAAO,SAASC,oBACdC,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEH,MAAMJ,eAAeQ,OAAO;gBAC5BF;YACF;SACD;IACH;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASG,sBACdC,MAA2B;IAE3BP,aACEO,QACAN,KAAK;QACHE,OAAOL;IACT,IACA,+EACAF,UAAUY,aAAa;AAE3B;AAEA,OAAO,MAAMC,6BAGT;IACF,CAACZ,eAAeQ,OAAO,CAAC,EAAEK,OAAOC,MAAM,CAAC;QACtCV,MAAMJ,eAAeQ,OAAO;QAC5BO,WAAW,CAACL,SAAWD,sBAAsBC;QAC7CM,WAAW,CAACC,QAAQP;YAClB,OAAO,OAAOQ;gBACZ,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAwDH;gBACzD,MAAMI,UAAUZ,OAAOJ,KAAK;gBAC5B,MAAM,EAAEiB,MAAM,EAAE,GAAGJ;gBACnB,IAAI,CAACjB,YAAYoB,SAASC,SAAS;oBACjC,MAAM,IAAIC,MACR,CAAC,EAAEH,OAAO,oCAAoC,EAAEE,OAAO,MAAM,CAAC;gBAElE;gBACA,OAAO,MAAMN,OAAOC;YACtB;QACF;IACF;AACF,EAAE"}

package/dist/esm/restricted/dialog.js

@@ -1,164 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { DialogType, ComponentStruct, enumValue, union } from '@metamask/snaps-sdk';
-import { createUnion } from '@metamask/snaps-utils';
-import { hasProperty } from '@metamask/utils';
-import { create, enums, object, optional, size, string, type } from 'superstruct';
-const methodName = 'snap_dialog';
-const PlaceholderStruct = optional(size(string(), 1, 40));
-/**
- * The specification builder for the `snap_dialog` permission. `snap_dialog`
- * lets the Snap display one of the following dialogs to the user:
- * - An alert, for displaying information.
- * - A confirmation, for accepting or rejecting some action.
- * - A prompt, for inputting some information.
- *
- * @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_dialog` permission.
- */ const specificationBuilder = ({ allowedCaveats = null, methodHooks })=>{
-    return {
-        permissionType: PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: getDialogImplementation(methodHooks),
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    showDialog: true,
-    createInterface: true,
-    getInterface: true
-};
-export const dialogBuilder = Object.freeze({
-    targetName: methodName,
-    specificationBuilder,
-    methodHooks
-});
-// Note: We use `type` here instead of `object` because `type` does not validate
-// the keys of the object, which is what we want.
-const BaseParamsStruct = type({
-    type: enums([
-        DialogType.Alert,
-        DialogType.Confirmation,
-        DialogType.Prompt
-    ])
-});
-const AlertParametersWithContentStruct = object({
-    type: enumValue(DialogType.Alert),
-    content: ComponentStruct
-});
-const AlertParametersWithIdStruct = object({
-    type: enumValue(DialogType.Alert),
-    id: string()
-});
-const AlertParametersStruct = union([
-    AlertParametersWithContentStruct,
-    AlertParametersWithIdStruct
-]);
-const ConfirmationParametersWithContentStruct = object({
-    type: enumValue(DialogType.Confirmation),
-    content: ComponentStruct
-});
-const ConfirmationParametersWithIdStruct = object({
-    type: enumValue(DialogType.Confirmation),
-    id: string()
-});
-const ConfirmationParametersStruct = union([
-    ConfirmationParametersWithContentStruct,
-    ConfirmationParametersWithIdStruct
-]);
-const PromptParametersWithContentStruct = object({
-    type: enumValue(DialogType.Prompt),
-    content: ComponentStruct,
-    placeholder: PlaceholderStruct
-});
-const PromptParametersWithIdStruct = object({
-    type: enumValue(DialogType.Prompt),
-    id: string(),
-    placeholder: PlaceholderStruct
-});
-const PromptParametersStruct = union([
-    PromptParametersWithContentStruct,
-    PromptParametersWithIdStruct
-]);
-const DialogParametersStruct = union([
-    AlertParametersStruct,
-    ConfirmationParametersStruct,
-    PromptParametersStruct
-]);
-const structs = {
-    [DialogType.Alert]: AlertParametersStruct,
-    [DialogType.Confirmation]: ConfirmationParametersStruct,
-    [DialogType.Prompt]: PromptParametersStruct
-};
-/**
- * Builds the method implementation for `snap_dialog`.
- *
- * @param hooks - The RPC method hooks.
- * @param hooks.showDialog - A function that shows the specified dialog in the
- * MetaMask UI and returns the appropriate value for the dialog type.
- * @param hooks.createInterface - A function that creates the interface in SnapInterfaceController.
- * @param hooks.getInterface - A function that gets an interface from SnapInterfaceController.
- * @returns The method implementation which return value depends on the dialog
- * type, valid return types are: string, boolean, null.
- */ export function getDialogImplementation({ showDialog, createInterface, getInterface }) {
-    return async function dialogImplementation(args) {
-        const { params, context: { origin } } = args;
-        const validatedType = getValidatedType(params);
-        const validatedParams = getValidatedParams(params, structs[validatedType]);
-        const placeholder = validatedParams.type === DialogType.Prompt ? validatedParams.placeholder : undefined;
-        if (hasProperty(validatedParams, 'content')) {
-            const id = await createInterface(origin, validatedParams.content);
-            return showDialog(origin, validatedType, id, placeholder);
-        }
-        // Verify that the passed interface ID is valid.
-        // This will throw if the interface ID is invalid (not created by the snap or doesn't exist)
-        try {
-            getInterface(origin, validatedParams.id);
-        } catch (error) {
-            throw rpcErrors.invalidParams({
-                message: `Invalid params: ${error.message}`
-            });
-        }
-        return showDialog(origin, validatedType, validatedParams.id, placeholder);
-    };
-}
-/**
- * Get the validated type of the dialog parameters. Throws an error if the type
- * is invalid.
- *
- * @param params - The parameters to validate.
- * @returns The validated type of the dialog parameters.
- */ function getValidatedType(params) {
-    try {
-        return create(params, BaseParamsStruct).type;
-    } catch (error) {
-        throw rpcErrors.invalidParams({
-            message: `The "type" property must be one of: ${Object.values(DialogType).join(', ')}.`
-        });
-    }
-}
-/**
- * Validates the confirm 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 struct - The struct to validate the params against.
- * @returns The validated confirm method parameter object.
- */ function getValidatedParams(params, struct) {
-    try {
-        return createUnion(params, struct, 'type');
-    } catch (error) {
-        throw rpcErrors.invalidParams({
-            message: `Invalid params: ${error.message}`
-        });
-    }
-}
-
-//# sourceMappingURL=dialog.js.map

package/dist/esm/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 {\n  DialogType,\n  ComponentStruct,\n  enumValue,\n  union,\n} from '@metamask/snaps-sdk';\nimport type {\n  DialogParams,\n  EnumToUnion,\n  Component,\n  InterfaceState,\n  SnapId,\n} from '@metamask/snaps-sdk';\nimport { createUnion } from '@metamask/snaps-utils';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport { hasProperty, 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  type,\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  id: string,\n  placeholder?: Placeholder,\n) => Promise<null | boolean | string>;\n\ntype CreateInterface = (snapId: string, content: Component) => Promise<string>;\ntype GetInterface = (\n  snapId: string,\n  id: string,\n) => { content: Component; snapId: SnapId; state: InterfaceState };\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 id - The interface ID.\n   * @param placeholder - The placeholder for the Prompt dialog input.\n   */\n  showDialog: ShowDialog;\n\n  /**\n   * @param snapId - The Snap ID creating the interface.\n   * @param content - The content of the interface.\n   */\n  createInterface: CreateInterface;\n  /**\n   * @param snapId - The SnapId requesting the interface.\n   * @param id - The interface ID.\n   */\n  getInterface: GetInterface;\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  createInterface: true,\n  getInterface: 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 AlertParametersWithContentStruct = object({\n  type: enumValue(DialogType.Alert),\n  content: ComponentStruct,\n});\nconst AlertParametersWithIdStruct = object({\n  type: enumValue(DialogType.Alert),\n  id: string(),\n});\n\nconst AlertParametersStruct = union([\n  AlertParametersWithContentStruct,\n  AlertParametersWithIdStruct,\n]);\n\nconst ConfirmationParametersWithContentStruct = object({\n  type: enumValue(DialogType.Confirmation),\n  content: ComponentStruct,\n});\n\nconst ConfirmationParametersWithIdStruct = object({\n  type: enumValue(DialogType.Confirmation),\n  id: string(),\n});\n\nconst ConfirmationParametersStruct = union([\n  ConfirmationParametersWithContentStruct,\n  ConfirmationParametersWithIdStruct,\n]);\n\nconst PromptParametersWithContentStruct = object({\n  type: enumValue(DialogType.Prompt),\n  content: ComponentStruct,\n  placeholder: PlaceholderStruct,\n});\n\nconst PromptParametersWithIdStruct = object({\n  type: enumValue(DialogType.Prompt),\n  id: string(),\n  placeholder: PlaceholderStruct,\n});\n\nconst PromptParametersStruct = union([\n  PromptParametersWithContentStruct,\n  PromptParametersWithIdStruct,\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.createInterface - A function that creates the interface in SnapInterfaceController.\n * @param hooks.getInterface - A function that gets an interface from SnapInterfaceController.\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  createInterface,\n  getInterface,\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 placeholder =\n      validatedParams.type === DialogType.Prompt\n        ? validatedParams.placeholder\n        : undefined;\n\n    if (hasProperty(validatedParams, 'content')) {\n      const id = await createInterface(\n        origin,\n        validatedParams.content as Component,\n      );\n      return showDialog(origin, validatedType, id, placeholder);\n    }\n\n    // Verify that the passed interface ID is valid.\n    // This will throw if the interface ID is invalid (not created by the snap or doesn't exist)\n    try {\n      getInterface(origin, validatedParams.id);\n    } catch (error) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}`,\n      });\n    }\n\n    return showDialog(origin, validatedType, validatedParams.id, 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, any>,\n): DialogParameters {\n  try {\n    return createUnion(params, struct, 'type');\n  } catch (error) {\n    throw rpcErrors.invalidParams({\n      message: `Invalid params: ${error.message}`,\n    });\n  }\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","DialogType","ComponentStruct","enumValue","union","createUnion","hasProperty","create","enums","object","optional","size","string","type","methodName","PlaceholderStruct","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","getDialogImplementation","subjectTypes","Snap","showDialog","createInterface","getInterface","dialogBuilder","Object","freeze","BaseParamsStruct","Alert","Confirmation","Prompt","AlertParametersWithContentStruct","content","AlertParametersWithIdStruct","id","AlertParametersStruct","ConfirmationParametersWithContentStruct","ConfirmationParametersWithIdStruct","ConfirmationParametersStruct","PromptParametersWithContentStruct","placeholder","PromptParametersWithIdStruct","PromptParametersStruct","DialogParametersStruct","structs","dialogImplementation","args","params","context","origin","validatedType","getValidatedType","validatedParams","getValidatedParams","undefined","error","invalidParams","message","values","join","struct"],"mappings":"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"}

package/dist/esm/restricted/getBip32Entropy.js

@@ -1,67 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SnapCaveatType } from '@metamask/snaps-utils';
-import { assert } from '@metamask/utils';
-import { getNode } from '../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: PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            SnapCaveatType.PermittedDerivationPaths
-        ],
-        methodImplementation: getBip32EntropyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedDerivationPaths) {
-                throw rpcErrors.invalidParams({
-                    message: `Expected a single "${SnapCaveatType.PermittedDerivationPaths}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-export const getBip32EntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getBip32Entropy`.
- *
- * @param hooks - The RPC method hooks.
- * @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.
- * @returns The method implementation which returns a `JsonSLIP10Node`.
- * @throws If the params are invalid.
- */ export function getBip32EntropyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip32Entropy(args) {
-        await getUnlockPromise(true);
-        const { params } = args;
-        assert(params);
-        const node = await getNode({
-            curve: params.curve,
-            path: params.path,
-            secretRecoveryPhrase: await getMnemonic()
-        });
-        return node.toJSON();
-    };
-}
-
-//# sourceMappingURL=getBip32Entropy.js.map

package/dist/esm/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":["PermissionType","SubjectType","rpcErrors","SnapCaveatType","assert","getNode","targetName","specificationBuilder","methodHooks","permissionType","RestrictedMethod","allowedCaveats","PermittedDerivationPaths","methodImplementation","getBip32EntropyImplementation","validator","caveats","length","type","invalidParams","message","subjectTypes","Snap","getMnemonic","getUnlockPromise","getBip32EntropyBuilder","Object","freeze","getBip32Entropy","args","params","node","curve","path","secretRecoveryPhrase","toJSON"],"mappings":"AAMA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAKjD,SAASC,cAAc,QAAQ,wBAAwB;AAEvD,SAASC,MAAM,QAAQ,kBAAkB;AAGzC,SAASC,OAAO,QAAQ,WAAW;AAEnC,MAAMC,aAAa;AA4BnB;;;;;;;;CAQC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAA8C;IAC9D,OAAO;QACLC,gBAAgBT,eAAeU,gBAAgB;QAC/CJ;QACAK,gBAAgB;YAACR,eAAeS,wBAAwB;SAAC;QACzDC,sBAAsBC,8BAA8BN;QACpDO,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKf,eAAeS,wBAAwB,EAC3D;gBACA,MAAMV,UAAUiB,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAEjB,eAAeS,wBAAwB,CAAC,SAAS,CAAC;gBACnF;YACF;QACF;QACAS,cAAc;YAACpB,YAAYqB,IAAI;SAAC;IAClC;AACF;AAEA,MAAMd,cAA6D;IACjEe,aAAa;IACbC,kBAAkB;AACpB;AAEA,OAAO,MAAMC,yBAAyBC,OAAOC,MAAM,CAAC;IAClDrB;IACAC;IACAC;AACF,GAAY;AAEZ;;;;;;;;;CASC,GACD,OAAO,SAASM,8BAA8B,EAC5CS,WAAW,EACXC,gBAAgB,EACW;IAC3B,OAAO,eAAeI,gBACpBC,IAAoD;QAEpD,MAAML,iBAAiB;QAEvB,MAAM,EAAEM,MAAM,EAAE,GAAGD;QACnBzB,OAAO0B;QAEP,MAAMC,OAAO,MAAM1B,QAAQ;YACzB2B,OAAOF,OAAOE,KAAK;YACnBC,MAAMH,OAAOG,IAAI;YACjBC,sBAAsB,MAAMX;QAC9B;QAEA,OAAOQ,KAAKI,MAAM;IACpB;AACF"}

package/dist/esm/restricted/getBip32PublicKey.js

@@ -1,79 +0,0 @@
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { bip32entropy, Bip32PathStruct, SnapCaveatType } from '@metamask/snaps-utils';
-import { assertStruct } from '@metamask/utils';
-import { boolean, enums, object, optional } from 'superstruct';
-import { getNode } from '../utils';
-const targetName = 'snap_getBip32PublicKey';
-export const Bip32PublicKeyArgsStruct = bip32entropy(object({
-    path: Bip32PathStruct,
-    curve: enums([
-        'ed25519',
-        'secp256k1'
-    ]),
-    compressed: optional(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: PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            SnapCaveatType.PermittedDerivationPaths
-        ],
-        methodImplementation: getBip32PublicKeyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedDerivationPaths) {
-                throw rpcErrors.invalidParams({
-                    message: `Expected a single "${SnapCaveatType.PermittedDerivationPaths}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-export const getBip32PublicKeyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getBip32PublicKey`.
- *
- * @param hooks - The RPC method hooks.
- * @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.
- * @returns The method implementation which returns a public key.
- * @throws If the params are invalid.
- */ export function getBip32PublicKeyImplementation({ getMnemonic, getUnlockPromise }) {
-    return async function getBip32PublicKey(args) {
-        await getUnlockPromise(true);
-        assertStruct(args.params, Bip32PublicKeyArgsStruct, 'Invalid BIP-32 public key params', rpcErrors.invalidParams);
-        const { params } = args;
-        const node = await 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/esm/restricted/getBip32PublicKey.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/restricted/getBip32PublicKey.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  GetBip32PublicKeyParams,\n  GetBip32PublicKeyResult,\n} from '@metamask/snaps-sdk';\nimport {\n  bip32entropy,\n  Bip32PathStruct,\n  SnapCaveatType,\n} from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { boolean, enums, object, optional } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\nimport { getNode } from '../utils';\n\nconst targetName = 'snap_getBip32PublicKey';\n\nexport type GetBip32PublicKeyMethodHooks = {\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 GetBip32PublicKeySpecificationBuilderOptions = {\n  methodHooks: GetBip32PublicKeyMethodHooks;\n};\n\ntype GetBip32PublicKeySpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof targetName;\n  methodImplementation: ReturnType<typeof getBip32PublicKeyImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\nexport const Bip32PublicKeyArgsStruct = bip32entropy(\n  object({\n    path: Bip32PathStruct,\n    curve: enums(['ed25519', 'secp256k1']),\n    compressed: optional(boolean()),\n  }),\n);\n\n/**\n * The specification builder for the `snap_getBip32PublicKey` permission.\n * `snap_getBip32PublicKey` lets the Snap retrieve public 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_getBip32PublicKey` permission.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  GetBip32PublicKeySpecificationBuilderOptions,\n  GetBip32PublicKeySpecification\n> = ({ methodHooks }: GetBip32PublicKeySpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName,\n    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],\n    methodImplementation: getBip32PublicKeyImplementation(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<GetBip32PublicKeyMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n};\n\nexport const getBip32PublicKeyBuilder = Object.freeze({\n  targetName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getBip32PublicKey`.\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 public key.\n * @throws If the params are invalid.\n */\nexport function getBip32PublicKeyImplementation({\n  getMnemonic,\n  getUnlockPromise,\n}: GetBip32PublicKeyMethodHooks) {\n  return async function getBip32PublicKey(\n    args: RestrictedMethodOptions<GetBip32PublicKeyParams>,\n  ): Promise<GetBip32PublicKeyResult> {\n    await getUnlockPromise(true);\n\n    assertStruct(\n      args.params,\n      Bip32PublicKeyArgsStruct,\n      'Invalid BIP-32 public key params',\n      rpcErrors.invalidParams,\n    );\n\n    const { params } = args;\n    const node = await getNode({\n      curve: params.curve,\n      path: params.path,\n      secretRecoveryPhrase: await getMnemonic(),\n    });\n\n    if (params.compressed) {\n      return node.compressedPublicKey;\n    }\n\n    return node.publicKey;\n  };\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","bip32entropy","Bip32PathStruct","SnapCaveatType","assertStruct","boolean","enums","object","optional","getNode","targetName","Bip32PublicKeyArgsStruct","path","curve","compressed","specificationBuilder","methodHooks","permissionType","RestrictedMethod","allowedCaveats","PermittedDerivationPaths","methodImplementation","getBip32PublicKeyImplementation","validator","caveats","length","type","invalidParams","message","subjectTypes","Snap","getMnemonic","getUnlockPromise","getBip32PublicKeyBuilder","Object","freeze","getBip32PublicKey","args","params","node","secretRecoveryPhrase","compressedPublicKey","publicKey"],"mappings":"AAMA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAKjD,SACEC,YAAY,EACZC,eAAe,EACfC,cAAc,QACT,wBAAwB;AAE/B,SAASC,YAAY,QAAQ,kBAAkB;AAC/C,SAASC,OAAO,EAAEC,KAAK,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,cAAc;AAG/D,SAASC,OAAO,QAAQ,WAAW;AAEnC,MAAMC,aAAa;AA4BnB,OAAO,MAAMC,2BAA2BV,aACtCM,OAAO;IACLK,MAAMV;IACNW,OAAOP,MAAM;QAAC;QAAW;KAAY;IACrCQ,YAAYN,SAASH;AACvB,IACA;AAEF;;;;;;;;CAQC,GACD,MAAMU,uBAIF,CAAC,EAAEC,WAAW,EAAgD;IAChE,OAAO;QACLC,gBAAgBnB,eAAeoB,gBAAgB;QAC/CR;QACAS,gBAAgB;YAAChB,eAAeiB,wBAAwB;SAAC;QACzDC,sBAAsBC,gCAAgCN;QACtDO,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKvB,eAAeiB,wBAAwB,EAC3D;gBACA,MAAMpB,UAAU2B,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAEzB,eAAeiB,wBAAwB,CAAC,SAAS,CAAC;gBACnF;YACF;QACF;QACAS,cAAc;YAAC9B,YAAY+B,IAAI;SAAC;IAClC;AACF;AAEA,MAAMd,cAA+D;IACnEe,aAAa;IACbC,kBAAkB;AACpB;AAEA,OAAO,MAAMC,2BAA2BC,OAAOC,MAAM,CAAC;IACpDzB;IACAK;IACAC;AACF,GAAY;AAEZ;;;;;;;;;CASC,GACD,OAAO,SAASM,gCAAgC,EAC9CS,WAAW,EACXC,gBAAgB,EACa;IAC7B,OAAO,eAAeI,kBACpBC,IAAsD;QAEtD,MAAML,iBAAiB;QAEvB5B,aACEiC,KAAKC,MAAM,EACX3B,0BACA,oCACAX,UAAU2B,aAAa;QAGzB,MAAM,EAAEW,MAAM,EAAE,GAAGD;QACnB,MAAME,OAAO,MAAM9B,QAAQ;YACzBI,OAAOyB,OAAOzB,KAAK;YACnBD,MAAM0B,OAAO1B,IAAI;YACjB4B,sBAAsB,MAAMT;QAC9B;QAEA,IAAIO,OAAOxB,UAAU,EAAE;YACrB,OAAOyB,KAAKE,mBAAmB;QACjC;QAEA,OAAOF,KAAKG,SAAS;IACvB;AACF"}

package/dist/esm/restricted/getBip44Entropy.js

@@ -1,69 +0,0 @@
-import { BIP44CoinTypeNode } from '@metamask/key-tree';
-import { PermissionType, SubjectType } from '@metamask/permission-controller';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { SnapCaveatType } from '@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: PermissionType.RestrictedMethod,
-        targetName,
-        allowedCaveats: [
-            SnapCaveatType.PermittedCoinTypes
-        ],
-        methodImplementation: getBip44EntropyImplementation(methodHooks),
-        validator: ({ caveats })=>{
-            if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedCoinTypes) {
-                throw rpcErrors.invalidParams({
-                    message: `Expected a single "${SnapCaveatType.PermittedCoinTypes}" caveat.`
-                });
-            }
-        },
-        subjectTypes: [
-            SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    getMnemonic: true,
-    getUnlockPromise: true
-};
-export const getBip44EntropyBuilder = Object.freeze({
-    targetName,
-    specificationBuilder,
-    methodHooks
-});
-/**
- * Builds the method implementation for `snap_getBip44Entropy`.
- *
- * @param hooks - The RPC method hooks.
- * @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.
- * @returns The method implementation which returns a `BIP44CoinTypeNode`.
- * @throws If the params are invalid.
- */ export 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 BIP44CoinTypeNode.fromDerivationPath([
-            await getMnemonic(),
-            `bip32:44'`,
-            `bip32:${params.coinType}'`
-        ]);
-        return node.toJSON();
-    };
-}
-
-//# sourceMappingURL=getBip44Entropy.js.map

package/dist/esm/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":["BIP44CoinTypeNode","PermissionType","SubjectType","rpcErrors","SnapCaveatType","targetName","specificationBuilder","methodHooks","permissionType","RestrictedMethod","allowedCaveats","PermittedCoinTypes","methodImplementation","getBip44EntropyImplementation","validator","caveats","length","type","invalidParams","message","subjectTypes","Snap","getMnemonic","getUnlockPromise","getBip44EntropyBuilder","Object","freeze","getBip44Entropy","args","params","node","fromDerivationPath","coinType","toJSON"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAOvD,SAASC,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AAKjD,SAASC,cAAc,QAAQ,wBAAwB;AAKvD,MAAMC,aAAa;AA4BnB;;;;;;;;;CASC,GACD,MAAMC,uBAIF,CAAC,EAAEC,WAAW,EAA8C;IAC9D,OAAO;QACLC,gBAAgBP,eAAeQ,gBAAgB;QAC/CJ;QACAK,gBAAgB;YAACN,eAAeO,kBAAkB;SAAC;QACnDC,sBAAsBC,8BAA8BN;QACpDO,WAAW,CAAC,EAAEC,OAAO,EAAE;YACrB,IACEA,SAASC,WAAW,KACpBD,OAAO,CAAC,EAAE,CAACE,IAAI,KAAKb,eAAeO,kBAAkB,EACrD;gBACA,MAAMR,UAAUe,aAAa,CAAC;oBAC5BC,SAAS,CAAC,mBAAmB,EAAEf,eAAeO,kBAAkB,CAAC,SAAS,CAAC;gBAC7E;YACF;QACF;QACAS,cAAc;YAAClB,YAAYmB,IAAI;SAAC;IAClC;AACF;AAEA,MAAMd,cAA6D;IACjEe,aAAa;IACbC,kBAAkB;AACpB;AAEA,OAAO,MAAMC,yBAAyBC,OAAOC,MAAM,CAAC;IAClDrB;IACAC;IACAC;AACF,GAAY;AAEZ;;;;;;;;;;;CAWC,GACD,OAAO,SAASM,8BAA8B,EAC5CS,WAAW,EACXC,gBAAgB,EACW;IAC3B,OAAO,eAAeI,gBACpBC,IAAoD;QAEpD,MAAML,iBAAiB;QAEvB,4EAA4E;QAC5E,MAAMM,SAASD,KAAKC,MAAM;QAE1B,MAAMC,OAAO,MAAM9B,kBAAkB+B,kBAAkB,CAAC;YACtD,MAAMT;YACN,CAAC,SAAS,CAAC;YACX,CAAC,MAAM,EAAEO,OAAOG,QAAQ,CAAC,CAAC,CAAC;SAC5B;QAED,OAAOF,KAAKG,MAAM;IACpB;AACF"}