@metamask/snaps-rpc-methods 5.0.0 → 7.0.0

package/dist/cjs/permitted/middleware.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createSnapsMethodMiddleware", {
-    enumerable: true,
-    get: function() {
-        return createSnapsMethodMiddleware;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("../utils");
-const _handlers = require("./handlers");
-function createSnapsMethodMiddleware(isSnap, hooks) {
-    // This is not actually a misused promise, the type is just wrong
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    return async function methodMiddleware(request, response, next, end) {
-        const handler = _handlers.methodHandlers[request.method];
-        if (handler) {
-            if (String.prototype.startsWith.call(request.method, 'snap_') && !isSnap) {
-                return end(_rpcerrors.rpcErrors.methodNotFound());
-            }
-            // TODO: Once json-rpc-engine types are up to date, we should type this correctly
-            const { implementation, hookNames } = handler;
-            try {
-                // Implementations may or may not be async, so we must await them.
-                return await implementation(request, response, next, end, (0, _utils.selectHooks)(hooks, hookNames));
-            } catch (error) {
-                (0, _snapsutils.logError)(error);
-                return end(error);
-            }
-        }
-        return next();
-    };
-}
-
-//# sourceMappingURL=middleware.js.map

package/dist/cjs/permitted/middleware.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/permitted/middleware.ts"],"sourcesContent":["import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { logError } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcParams } from '@metamask/utils';\n\nimport { selectHooks } from '../utils';\nimport { methodHandlers } from './handlers';\n\n/**\n * Creates a middleware that handles permitted snap RPC methods.\n *\n * @param isSnap - A flag that should indicate whether the requesting origin is a snap or not.\n * @param hooks - An object containing the hooks made available to the permitted RPC methods.\n * @returns The middleware.\n */\nexport function createSnapsMethodMiddleware(\n  isSnap: boolean,\n  hooks: Record<string, unknown>,\n): JsonRpcMiddleware<JsonRpcParams, Json> {\n  // This is not actually a misused promise, the type is just wrong\n  // eslint-disable-next-line @typescript-eslint/no-misused-promises\n  return async function methodMiddleware(request, response, next, end) {\n    const handler =\n      methodHandlers[request.method as keyof typeof methodHandlers];\n    if (handler) {\n      if (\n        String.prototype.startsWith.call(request.method, 'snap_') &&\n        !isSnap\n      ) {\n        return end(rpcErrors.methodNotFound());\n      }\n\n      // TODO: Once json-rpc-engine types are up to date, we should type this correctly\n      const { implementation, hookNames } = handler as any;\n      try {\n        // Implementations may or may not be async, so we must await them.\n        return await implementation(\n          request,\n          response,\n          next,\n          end,\n          selectHooks(hooks, hookNames),\n        );\n      } catch (error) {\n        logError(error);\n        return end(error);\n      }\n    }\n\n    return next();\n  };\n}\n"],"names":["createSnapsMethodMiddleware","isSnap","hooks","methodMiddleware","request","response","next","end","handler","methodHandlers","method","String","prototype","startsWith","call","rpcErrors","methodNotFound","implementation","hookNames","selectHooks","error","logError"],"mappings":";;;;+BAegBA;;;eAAAA;;;2BAdU;4BACD;uBAGG;0BACG;AASxB,SAASA,4BACdC,MAAe,EACfC,KAA8B;IAE9B,iEAAiE;IACjE,kEAAkE;IAClE,OAAO,eAAeC,iBAAiBC,OAAO,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,GAAG;QACjE,MAAMC,UACJC,wBAAc,CAACL,QAAQM,MAAM,CAAgC;QAC/D,IAAIF,SAAS;YACX,IACEG,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACV,QAAQM,MAAM,EAAE,YACjD,CAACT,QACD;gBACA,OAAOM,IAAIQ,oBAAS,CAACC,cAAc;YACrC;YAEA,iFAAiF;YACjF,MAAM,EAAEC,cAAc,EAAEC,SAAS,EAAE,GAAGV;YACtC,IAAI;gBACF,kEAAkE;gBAClE,OAAO,MAAMS,eACXb,SACAC,UACAC,MACAC,KACAY,IAAAA,kBAAW,EAACjB,OAAOgB;YAEvB,EAAE,OAAOE,OAAO;gBACdC,IAAAA,oBAAQ,EAACD;gBACT,OAAOb,IAAIa;YACb;QACF;QAEA,OAAOd;IACT;AACF"}

package/dist/cjs/permitted/requestSnaps.js

@@ -1,123 +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, {
-    requestSnapsHandler: function() {
-        return requestSnapsHandler;
-    },
-    hasRequestedSnaps: function() {
-        return hasRequestedSnaps;
-    },
-    getSnapPermissionsRequest: function() {
-        return getSnapPermissionsRequest;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _invokeSnap = require("../restricted/invokeSnap");
-const hookNames = {
-    installSnaps: true,
-    requestPermissions: true,
-    getPermissions: true
-};
-const requestSnapsHandler = {
-    methodNames: [
-        'wallet_requestSnaps'
-    ],
-    implementation: requestSnapsImplementation,
-    hookNames
-};
-function hasRequestedSnaps(existingPermissions, requestedSnaps) {
-    const snapIdCaveat = existingPermissions[_invokeSnap.WALLET_SNAP_PERMISSION_KEY]?.caveats?.find((caveat)=>caveat.type === _snapsutils.SnapCaveatType.SnapIds);
-    const permittedSnaps = snapIdCaveat?.value;
-    if ((0, _utils.isObject)(permittedSnaps)) {
-        return Object.keys(requestedSnaps).every((requestedSnap)=>(0, _utils.hasProperty)(permittedSnaps, requestedSnap));
-    }
-    return false;
-}
-function getSnapPermissionsRequest(existingPermissions, requestedPermissions) {
-    (0, _snapsutils.verifyRequestedSnapPermissions)(requestedPermissions);
-    if (!existingPermissions[_invokeSnap.WALLET_SNAP_PERMISSION_KEY]) {
-        return requestedPermissions;
-    }
-    const snapIdCaveat = existingPermissions[_invokeSnap.WALLET_SNAP_PERMISSION_KEY].caveats?.find((caveat)=>caveat.type === _snapsutils.SnapCaveatType.SnapIds);
-    const permittedSnaps = (snapIdCaveat?.value) ?? {};
-    const requestedSnaps = requestedPermissions[_invokeSnap.WALLET_SNAP_PERMISSION_KEY].caveats[0].value;
-    const snapIdSet = new Set([
-        ...Object.keys(permittedSnaps),
-        ...Object.keys(requestedSnaps)
-    ]);
-    const mergedCaveatValue = [
-        ...snapIdSet
-    ].reduce((request, snapId)=>{
-        request[snapId] = requestedSnaps[snapId] ?? permittedSnaps[snapId];
-        return request;
-    }, {});
-    requestedPermissions[_invokeSnap.WALLET_SNAP_PERMISSION_KEY].caveats[0].value = mergedCaveatValue;
-    return requestedPermissions;
-}
-/**
- * The `wallet_requestSnaps` method implementation.
- * Tries to install the requested snaps and adds them to the JSON-RPC response.
- *
- * @param req - The JSON-RPC request object.
- * @param res - The JSON-RPC response object.
- * @param _next - The `json-rpc-engine` "next" callback. Not used by this
- * function.
- * @param end - The `json-rpc-engine` "end" callback.
- * @param hooks - The RPC method hooks.
- * @param hooks.installSnaps - A function that tries to install a given snap, prompting the user if necessary.
- * @param hooks.requestPermissions - A function that requests permissions on
- * behalf of a subject.
- * @param hooks.getPermissions - A function that gets the current permissions.
- * @returns A promise that resolves once the JSON-RPC response has been modified.
- * @throws If the params are invalid.
- */ async function requestSnapsImplementation(req, res, _next, end, { installSnaps, requestPermissions, getPermissions }) {
-    const requestedSnaps = req.params;
-    if (!(0, _utils.isObject)(requestedSnaps)) {
-        return end(_rpcerrors.rpcErrors.invalidParams({
-            message: '"params" must be an object.'
-        }));
-    }
-    try {
-        if (Object.keys(requestedSnaps).length === 0) {
-            return end(_rpcerrors.rpcErrors.invalidParams({
-                message: 'Request must have at least one requested snap.'
-            }));
-        }
-        const requestedPermissions = {
-            [_invokeSnap.WALLET_SNAP_PERMISSION_KEY]: {
-                caveats: [
-                    {
-                        type: _snapsutils.SnapCaveatType.SnapIds,
-                        value: requestedSnaps
-                    }
-                ]
-            }
-        };
-        const existingPermissions = await getPermissions();
-        if (!existingPermissions) {
-            const [, metadata] = await requestPermissions(requestedPermissions);
-            res.result = metadata.data[_invokeSnap.WALLET_SNAP_PERMISSION_KEY];
-        } else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {
-            res.result = await installSnaps(requestedSnaps);
-        } else {
-            const mergedPermissionsRequest = getSnapPermissionsRequest(existingPermissions, requestedPermissions);
-            const [, metadata] = await requestPermissions(mergedPermissionsRequest);
-            res.result = metadata.data[_invokeSnap.WALLET_SNAP_PERMISSION_KEY];
-        }
-    } catch (error) {
-        res.error = error;
-    }
-    return end();
-}
-
-//# sourceMappingURL=requestSnaps.js.map

package/dist/cjs/permitted/requestSnaps.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/permitted/requestSnaps.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type {\n  PermissionConstraint,\n  RequestedPermissions,\n  Caveat,\n  PermittedHandlerExport,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  RequestSnapsParams,\n  RequestSnapsResult,\n} from '@metamask/snaps-sdk';\nimport type { SnapsPermissionRequest } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  verifyRequestedSnapPermissions,\n} from '@metamask/snaps-utils';\nimport type {\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n  Json,\n} from '@metamask/utils';\nimport { hasProperty, isObject } from '@metamask/utils';\n\nimport { WALLET_SNAP_PERMISSION_KEY } from '../restricted/invokeSnap';\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<RequestSnapsHooks> = {\n  installSnaps: true,\n  requestPermissions: true,\n  getPermissions: true,\n};\n\n/**\n * `wallet_requestSnaps` installs the requested Snaps and requests permission to use them if necessary.\n */\nexport const requestSnapsHandler: PermittedHandlerExport<\n  RequestSnapsHooks,\n  RequestSnapsParams,\n  RequestSnapsResult\n> = {\n  methodNames: ['wallet_requestSnaps'],\n  implementation: requestSnapsImplementation,\n  hookNames,\n};\n\nexport type RequestSnapsHooks = {\n  /**\n   * Installs the requested snaps if they are permitted.\n   */\n  installSnaps: (\n    requestedSnaps: RequestSnapsParams,\n  ) => Promise<RequestSnapsResult>;\n\n  /**\n   * Initiates a permission request for the requesting origin.\n   *\n   * @returns The result of the permissions request.\n   */\n  requestPermissions: (\n    permissions: RequestedPermissions,\n  ) => Promise<\n    [\n      Record<string, PermissionConstraint>,\n      { data: Record<string, unknown>; id: string; origin: string },\n    ]\n  >;\n\n  /**\n   * Gets the current permissions for the requesting origin.\n   *\n   * @returns The current permissions of the requesting origin.\n   */\n  getPermissions: () => Promise<\n    Record<string, PermissionConstraint> | undefined\n  >;\n};\n\n/**\n * Checks whether an origin has existing `wallet_snap` permission and\n * whether or not it has the requested snapIds caveat.\n *\n * @param existingPermissions - The existing permissions for the origin.\n * @param requestedSnaps - The requested snaps.\n * @returns True if the existing permissions satisfy the requested snaps, otherwise false.\n */\nexport function hasRequestedSnaps(\n  existingPermissions: Record<string, PermissionConstraint>,\n  requestedSnaps: Record<string, unknown>,\n): boolean {\n  const snapIdCaveat = existingPermissions[\n    WALLET_SNAP_PERMISSION_KEY\n  ]?.caveats?.find(\n    (caveat: Caveat<string, Json>) => caveat.type === SnapCaveatType.SnapIds,\n  );\n\n  const permittedSnaps = snapIdCaveat?.value;\n  if (isObject(permittedSnaps)) {\n    return Object.keys(requestedSnaps).every((requestedSnap) =>\n      hasProperty(permittedSnaps, requestedSnap),\n    );\n  }\n  return false;\n}\n\n/**\n * Constructs a valid permission request with merged caveats based on existing permissions\n * and the requested snaps.\n *\n * @param existingPermissions - The existing permissions for the origin.\n * @param requestedPermissions - The permission request passed into `requestPermissions`.\n * @returns `requestedPermissions`.\n */\nexport function getSnapPermissionsRequest(\n  existingPermissions: Record<string, PermissionConstraint>,\n  requestedPermissions: unknown,\n): SnapsPermissionRequest {\n  verifyRequestedSnapPermissions(requestedPermissions);\n\n  if (!existingPermissions[WALLET_SNAP_PERMISSION_KEY]) {\n    return requestedPermissions;\n  }\n\n  const snapIdCaveat = existingPermissions[\n    WALLET_SNAP_PERMISSION_KEY\n  ].caveats?.find(\n    (caveat: Caveat<string, Json>) => caveat.type === SnapCaveatType.SnapIds,\n  );\n\n  const permittedSnaps = (snapIdCaveat?.value as Record<string, Json>) ?? {};\n\n  const requestedSnaps =\n    requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value;\n\n  const snapIdSet = new Set([\n    ...Object.keys(permittedSnaps),\n    ...Object.keys(requestedSnaps),\n  ]);\n\n  const mergedCaveatValue = [...snapIdSet].reduce<Record<string, Json>>(\n    (request, snapId) => {\n      request[snapId] = requestedSnaps[snapId] ?? permittedSnaps[snapId];\n      return request;\n    },\n    {},\n  );\n\n  requestedPermissions[WALLET_SNAP_PERMISSION_KEY].caveats[0].value =\n    mergedCaveatValue;\n\n  return requestedPermissions;\n}\n\n/**\n * The `wallet_requestSnaps` method implementation.\n * Tries to install the requested snaps and adds them to the JSON-RPC response.\n *\n * @param req - The JSON-RPC request object.\n * @param res - The JSON-RPC response object.\n * @param _next - The `json-rpc-engine` \"next\" callback. Not used by this\n * function.\n * @param end - The `json-rpc-engine` \"end\" callback.\n * @param hooks - The RPC method hooks.\n * @param hooks.installSnaps - A function that tries to install a given snap, prompting the user if necessary.\n * @param hooks.requestPermissions - A function that requests permissions on\n * behalf of a subject.\n * @param hooks.getPermissions - A function that gets the current permissions.\n * @returns A promise that resolves once the JSON-RPC response has been modified.\n * @throws If the params are invalid.\n */\nasync function requestSnapsImplementation(\n  req: JsonRpcRequest<RequestSnapsParams>,\n  res: PendingJsonRpcResponse<RequestSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { installSnaps, requestPermissions, getPermissions }: RequestSnapsHooks,\n): Promise<void> {\n  const requestedSnaps = req.params;\n  if (!isObject(requestedSnaps)) {\n    return end(\n      rpcErrors.invalidParams({\n        message: '\"params\" must be an object.',\n      }),\n    );\n  }\n\n  try {\n    if (Object.keys(requestedSnaps).length === 0) {\n      return end(\n        rpcErrors.invalidParams({\n          message: 'Request must have at least one requested snap.',\n        }),\n      );\n    }\n\n    const requestedPermissions = {\n      [WALLET_SNAP_PERMISSION_KEY]: {\n        caveats: [{ type: SnapCaveatType.SnapIds, value: requestedSnaps }],\n      },\n    } as RequestedPermissions;\n    const existingPermissions = await getPermissions();\n\n    if (!existingPermissions) {\n      const [, metadata] = await requestPermissions(requestedPermissions);\n      res.result = metadata.data[\n        WALLET_SNAP_PERMISSION_KEY\n      ] as RequestSnapsResult;\n    } else if (hasRequestedSnaps(existingPermissions, requestedSnaps)) {\n      res.result = await installSnaps(requestedSnaps);\n    } else {\n      const mergedPermissionsRequest = getSnapPermissionsRequest(\n        existingPermissions,\n        requestedPermissions,\n      );\n\n      const [, metadata] = await requestPermissions(mergedPermissionsRequest);\n      res.result = metadata.data[\n        WALLET_SNAP_PERMISSION_KEY\n      ] as RequestSnapsResult;\n    }\n  } catch (error) {\n    res.error = error;\n  }\n\n  return end();\n}\n"],"names":["requestSnapsHandler","hasRequestedSnaps","getSnapPermissionsRequest","hookNames","installSnaps","requestPermissions","getPermissions","methodNames","implementation","requestSnapsImplementation","existingPermissions","requestedSnaps","snapIdCaveat","WALLET_SNAP_PERMISSION_KEY","caveats","find","caveat","type","SnapCaveatType","SnapIds","permittedSnaps","value","isObject","Object","keys","every","requestedSnap","hasProperty","requestedPermissions","verifyRequestedSnapPermissions","snapIdSet","Set","mergedCaveatValue","reduce","request","snapId","req","res","_next","end","params","rpcErrors","invalidParams","message","length","metadata","result","data","mergedPermissionsRequest","error"],"mappings":"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"}

package/dist/cjs/restricted/caveats/index.js

@@ -1,38 +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, {
-    caveatSpecifications: function() {
-        return caveatSpecifications;
-    },
-    caveatMappers: function() {
-        return caveatMappers;
-    }
-});
-const _getBip32Entropy = require("../getBip32Entropy");
-const _getBip32PublicKey = require("../getBip32PublicKey");
-const _getBip44Entropy = require("../getBip44Entropy");
-const _invokeSnap = require("../invokeSnap");
-const _permittedCoinTypes = require("./permittedCoinTypes");
-const _permittedDerivationPaths = require("./permittedDerivationPaths");
-const _snapIds = require("./snapIds");
-const caveatSpecifications = {
-    ..._permittedDerivationPaths.PermittedDerivationPathsCaveatSpecification,
-    ..._permittedCoinTypes.PermittedCoinTypesCaveatSpecification,
-    ..._snapIds.SnapIdsCaveatSpecification
-};
-const caveatMappers = {
-    [_getBip32Entropy.getBip32EntropyBuilder.targetName]: _permittedDerivationPaths.permittedDerivationPathsCaveatMapper,
-    [_getBip32PublicKey.getBip32PublicKeyBuilder.targetName]: _permittedDerivationPaths.permittedDerivationPathsCaveatMapper,
-    [_getBip44Entropy.getBip44EntropyBuilder.targetName]: _permittedCoinTypes.permittedCoinTypesCaveatMapper,
-    [_invokeSnap.invokeSnapBuilder.targetName]: _snapIds.snapIdsCaveatMapper
-};
-
-//# sourceMappingURL=index.js.map

package/dist/cjs/restricted/caveats/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/restricted/caveats/index.ts"],"sourcesContent":["import type { PermissionConstraint } from '@metamask/permission-controller';\nimport type { Json } from '@metamask/utils';\n\nimport { getBip32EntropyBuilder } from '../getBip32Entropy';\nimport { getBip32PublicKeyBuilder } from '../getBip32PublicKey';\nimport { getBip44EntropyBuilder } from '../getBip44Entropy';\nimport { invokeSnapBuilder } from '../invokeSnap';\nimport {\n  permittedCoinTypesCaveatMapper,\n  PermittedCoinTypesCaveatSpecification,\n} from './permittedCoinTypes';\nimport {\n  permittedDerivationPathsCaveatMapper,\n  PermittedDerivationPathsCaveatSpecification,\n} from './permittedDerivationPaths';\nimport { snapIdsCaveatMapper, SnapIdsCaveatSpecification } from './snapIds';\n\nexport const caveatSpecifications = {\n  ...PermittedDerivationPathsCaveatSpecification,\n  ...PermittedCoinTypesCaveatSpecification,\n  ...SnapIdsCaveatSpecification,\n} as const;\n\nexport const caveatMappers: Record<\n  string,\n  (value: Json) => Pick<PermissionConstraint, 'caveats'>\n> = {\n  [getBip32EntropyBuilder.targetName]: permittedDerivationPathsCaveatMapper,\n  [getBip32PublicKeyBuilder.targetName]: permittedDerivationPathsCaveatMapper,\n  [getBip44EntropyBuilder.targetName]: permittedCoinTypesCaveatMapper,\n  [invokeSnapBuilder.targetName]: snapIdsCaveatMapper,\n};\n"],"names":["caveatSpecifications","caveatMappers","PermittedDerivationPathsCaveatSpecification","PermittedCoinTypesCaveatSpecification","SnapIdsCaveatSpecification","getBip32EntropyBuilder","targetName","permittedDerivationPathsCaveatMapper","getBip32PublicKeyBuilder","getBip44EntropyBuilder","permittedCoinTypesCaveatMapper","invokeSnapBuilder","snapIdsCaveatMapper"],"mappings":";;;;;;;;;;;IAiBaA,oBAAoB;eAApBA;;IAMAC,aAAa;eAAbA;;;iCApB0B;mCACE;iCACF;4BACL;oCAI3B;0CAIA;yBACyD;AAEzD,MAAMD,uBAAuB;IAClC,GAAGE,qEAA2C;IAC9C,GAAGC,yDAAqC;IACxC,GAAGC,mCAA0B;AAC/B;AAEO,MAAMH,gBAGT;IACF,CAACI,uCAAsB,CAACC,UAAU,CAAC,EAAEC,8DAAoC;IACzE,CAACC,2CAAwB,CAACF,UAAU,CAAC,EAAEC,8DAAoC;IAC3E,CAACE,uCAAsB,CAACH,UAAU,CAAC,EAAEI,kDAA8B;IACnE,CAACC,6BAAiB,CAACL,UAAU,CAAC,EAAEM,4BAAmB;AACrD"}

package/dist/cjs/restricted/caveats/permittedCoinTypes.js

@@ -1,83 +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, {
-    permittedCoinTypesCaveatMapper: function() {
-        return permittedCoinTypesCaveatMapper;
-    },
-    validateBIP44Params: function() {
-        return validateBIP44Params;
-    },
-    validateBIP44Caveat: function() {
-        return validateBIP44Caveat;
-    },
-    PermittedCoinTypesCaveatSpecification: function() {
-        return PermittedCoinTypesCaveatSpecification;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-function permittedCoinTypesCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: _snapsutils.SnapCaveatType.PermittedCoinTypes,
-                value
-            }
-        ]
-    };
-}
-function validateBIP44Params(value) {
-    if (!(0, _utils.isPlainObject)(value) || !(0, _utils.hasProperty)(value, 'coinType')) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: 'Expected a plain object containing a coin type.'
-        });
-    }
-    if (typeof value.coinType !== 'number' || !Number.isInteger(value.coinType) || value.coinType < 0 || value.coinType > 0x7fffffff) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: 'Invalid "coinType" parameter. Coin type must be a non-negative integer.'
-        });
-    }
-    if (_snapsutils.FORBIDDEN_COIN_TYPES.includes(value.coinType)) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: `Coin type ${value.coinType} is forbidden.`
-        });
-    }
-}
-function validateBIP44Caveat(caveat) {
-    if (!(0, _utils.hasProperty)(caveat, 'value') || !Array.isArray(caveat.value) || caveat.value.length === 0) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: 'Expected non-empty array of coin types.'
-        });
-    }
-    caveat.value.forEach(validateBIP44Params);
-}
-const PermittedCoinTypesCaveatSpecification = {
-    [_snapsutils.SnapCaveatType.PermittedCoinTypes]: Object.freeze({
-        type: _snapsutils.SnapCaveatType.PermittedCoinTypes,
-        decorator: (method, caveat)=>{
-            return async (args)=>{
-                const { params } = args;
-                validateBIP44Params(params);
-                const coinType = caveat.value.find((caveatValue)=>caveatValue.coinType === params.coinType);
-                if (!coinType) {
-                    throw _rpcerrors.providerErrors.unauthorized({
-                        message: 'The requested coin type is not permitted. Allowed coin types must be specified in the snap manifest.'
-                    });
-                }
-                return await method(args);
-            };
-        },
-        validator: (caveat)=>validateBIP44Caveat(caveat)
-    })
-};
-
-//# sourceMappingURL=permittedCoinTypes.js.map

package/dist/cjs/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":["permittedCoinTypesCaveatMapper","validateBIP44Params","validateBIP44Caveat","PermittedCoinTypesCaveatSpecification","value","caveats","type","SnapCaveatType","PermittedCoinTypes","isPlainObject","hasProperty","rpcErrors","invalidParams","message","coinType","Number","isInteger","FORBIDDEN_COIN_TYPES","includes","caveat","Array","isArray","length","forEach","Object","freeze","decorator","method","args","params","find","caveatValue","providerErrors","unauthorized","validator"],"mappings":";;;;;;;;;;;IAmBgBA,8BAA8B;eAA9BA;;IAmBAC,mBAAmB;eAAnBA;;IAmCAC,mBAAmB;eAAnBA;;IAcHC,qCAAqC;eAArCA;;;2BAlF6B;4BAEW;uBAEV;AAUpC,SAASH,+BACdI,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEC,MAAMC,0BAAc,CAACC,kBAAkB;gBACvCJ;YACF;SACD;IACH;AACF;AAQO,SAASH,oBACdG,KAAc;IAEd,IAAI,CAACK,IAAAA,oBAAa,EAACL,UAAU,CAACM,IAAAA,kBAAW,EAACN,OAAO,aAAa;QAC5D,MAAMO,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,IACE,OAAOT,MAAMU,QAAQ,KAAK,YAC1B,CAACC,OAAOC,SAAS,CAACZ,MAAMU,QAAQ,KAChCV,MAAMU,QAAQ,GAAG,KACjBV,MAAMU,QAAQ,GAAG,YACjB;QACA,MAAMH,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SACE;QACJ;IACF;IAEA,IAAII,gCAAoB,CAACC,QAAQ,CAACd,MAAMU,QAAQ,GAAG;QACjD,MAAMH,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS,CAAC,UAAU,EAAET,MAAMU,QAAQ,CAAC,cAAc,CAAC;QACtD;IACF;AACF;AASO,SAASZ,oBAAoBiB,MAA2B;IAC7D,IACE,CAACT,IAAAA,kBAAW,EAACS,QAAQ,YACrB,CAACC,MAAMC,OAAO,CAACF,OAAOf,KAAK,KAC3Be,OAAOf,KAAK,CAACkB,MAAM,KAAK,GACxB;QACA,MAAMX,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEAM,OAAOf,KAAK,CAACmB,OAAO,CAACtB;AACvB;AAEO,MAAME,wCAGT;IACF,CAACI,0BAAc,CAACC,kBAAkB,CAAC,EAAEgB,OAAOC,MAAM,CAAC;QACjDnB,MAAMC,0BAAc,CAACC,kBAAkB;QACvCkB,WAAW,CACTC,QACAR;YAKA,OAAO,OAAOS;gBACZ,MAAM,EAAEC,MAAM,EAAE,GAAGD;gBACnB3B,oBAAoB4B;gBAEpB,MAAMf,WAAWK,OAAOf,KAAK,CAAC0B,IAAI,CAChC,CAACC,cAAgBA,YAAYjB,QAAQ,KAAKe,OAAOf,QAAQ;gBAG3D,IAAI,CAACA,UAAU;oBACb,MAAMkB,yBAAc,CAACC,YAAY,CAAC;wBAChCpB,SACE;oBACJ;gBACF;gBAEA,OAAO,MAAMc,OAAOC;YACtB;QACF;QACAM,WAAW,CAACf,SAAWjB,oBAAoBiB;IAC7C;AACF"}

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

@@ -1,67 +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, {
-    permittedDerivationPathsCaveatMapper: function() {
-        return permittedDerivationPathsCaveatMapper;
-    },
-    validateBIP32Path: function() {
-        return validateBIP32Path;
-    },
-    validateBIP32CaveatPaths: function() {
-        return validateBIP32CaveatPaths;
-    },
-    PermittedDerivationPathsCaveatSpecification: function() {
-        return PermittedDerivationPathsCaveatSpecification;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-function permittedDerivationPathsCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: _snapsutils.SnapCaveatType.PermittedDerivationPaths,
-                value
-            }
-        ]
-    };
-}
-function validateBIP32Path(value) {
-    (0, _utils.assertStruct)(value, _snapsutils.Bip32EntropyStruct, 'Invalid BIP-32 entropy path definition', _rpcerrors.rpcErrors.invalidParams);
-}
-function validateBIP32CaveatPaths(caveat) {
-    (0, _utils.assertStruct)(caveat, (0, _superstruct.type)({
-        value: (0, _superstruct.size)((0, _superstruct.array)(_snapsutils.Bip32EntropyStruct), 1, Infinity)
-    }), 'Invalid BIP-32 entropy caveat', _rpcerrors.rpcErrors.internal);
-}
-const PermittedDerivationPathsCaveatSpecification = {
-    [_snapsutils.SnapCaveatType.PermittedDerivationPaths]: Object.freeze({
-        type: _snapsutils.SnapCaveatType.PermittedDerivationPaths,
-        decorator: (method, caveat)=>{
-            return async (args)=>{
-                const { params } = args;
-                validateBIP32Path(params);
-                const path = caveat.value.find((caveatPath)=>(0, _snapsutils.isEqual)(params.path.slice(0, caveatPath.path.length), caveatPath.path) && caveatPath.curve === params.curve);
-                if (!path) {
-                    throw _rpcerrors.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/cjs/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":["permittedDerivationPathsCaveatMapper","validateBIP32Path","validateBIP32CaveatPaths","PermittedDerivationPathsCaveatSpecification","value","caveats","type","SnapCaveatType","PermittedDerivationPaths","assertStruct","Bip32EntropyStruct","rpcErrors","invalidParams","caveat","size","array","Infinity","internal","Object","freeze","decorator","method","args","params","path","find","caveatPath","isEqual","slice","length","curve","providerErrors","unauthorized","message","validator"],"mappings":";;;;;;;;;;;IAwBgBA,oCAAoC;eAApCA;;IAsBAC,iBAAiB;eAAjBA;;IAkBAC,wBAAwB;eAAxBA;;IAWHC,2CAA2C;eAA3CA;;;2BAtE6B;4BAMnC;uBAEsB;6BACK;AAU3B,SAASH,qCACdI,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEC,MAAMC,0BAAc,CAACC,wBAAwB;gBAC7CJ;YACF;SACD;IACH;AACF;AAWO,SAASH,kBACdG,KAAc;IAEdK,IAAAA,mBAAY,EACVL,OACAM,8BAAkB,EAClB,0CACAC,oBAAS,CAACC,aAAa;AAE3B;AASO,SAASV,yBACdW,MAA2B;IAE3BJ,IAAAA,mBAAY,EACVI,QACAP,IAAAA,iBAAI,EAAC;QAAEF,OAAOU,IAAAA,iBAAI,EAACC,IAAAA,kBAAK,EAACL,8BAAkB,GAAG,GAAGM;IAAU,IAC3D,iCACAL,oBAAS,CAACM,QAAQ;AAEtB;AAEO,MAAMd,8CAGT;IACF,CAACI,0BAAc,CAACC,wBAAwB,CAAC,EAAEU,OAAOC,MAAM,CAAC;QACvDb,MAAMC,0BAAc,CAACC,wBAAwB;QAC7CY,WAAW,CACTC,QACAR;YAEA,OAAO,OAAOS;gBACZ,MAAM,EAAEC,MAAM,EAAE,GAAGD;gBACnBrB,kBAAkBsB;gBAElB,MAAMC,OAAOX,OAAOT,KAAK,CAACqB,IAAI,CAC5B,CAACC,aACCC,IAAAA,mBAAO,EACLJ,OAAOC,IAAI,CAACI,KAAK,CAAC,GAAGF,WAAWF,IAAI,CAACK,MAAM,GAC3CH,WAAWF,IAAI,KACZE,WAAWI,KAAK,KAAKP,OAAOO,KAAK;gBAG1C,IAAI,CAACN,MAAM;oBACT,MAAMO,yBAAc,CAACC,YAAY,CAAC;wBAChCC,SACE;oBACJ;gBACF;gBAEA,OAAO,MAAMZ,OAAOC;YACtB;QACF;QACAY,WAAW,CAACrB,SAAWX,yBAAyBW;IAClD;AACF"}

package/dist/cjs/restricted/caveats/snapIds.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, {
-    snapIdsCaveatMapper: function() {
-        return snapIdsCaveatMapper;
-    },
-    validateSnapIdsCaveat: function() {
-        return validateSnapIdsCaveat;
-    },
-    SnapIdsCaveatSpecification: function() {
-        return SnapIdsCaveatSpecification;
-    }
-});
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapsutils = require("@metamask/snaps-utils");
-const _utils = require("@metamask/utils");
-const _superstruct = require("superstruct");
-function snapIdsCaveatMapper(value) {
-    return {
-        caveats: [
-            {
-                type: _snapsutils.SnapCaveatType.SnapIds,
-                value
-            }
-        ]
-    };
-}
-function validateSnapIdsCaveat(caveat) {
-    (0, _utils.assertStruct)(caveat, (0, _superstruct.type)({
-        value: _snapsutils.SnapIdsStruct
-    }), 'Expected caveat to have a value property of a non-empty object of snap IDs.', _rpcerrors.rpcErrors.invalidParams);
-}
-const SnapIdsCaveatSpecification = {
-    [_snapsutils.SnapCaveatType.SnapIds]: Object.freeze({
-        type: _snapsutils.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 (!(0, _utils.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/cjs/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":["snapIdsCaveatMapper","validateSnapIdsCaveat","SnapIdsCaveatSpecification","value","caveats","type","SnapCaveatType","SnapIds","caveat","assertStruct","SnapIdsStruct","rpcErrors","invalidParams","Object","freeze","validator","decorator","method","args","params","context","origin","snapIds","snapId","hasProperty","Error"],"mappings":";;;;;;;;;;;IAwBgBA,mBAAmB;eAAnBA;;IAmBAC,qBAAqB;eAArBA;;IAaHC,0BAA0B;eAA1BA;;;2BAjDa;4BAEoB;uBAEJ;6BACrB;AAYd,SAASF,oBACdG,KAAW;IAEX,OAAO;QACLC,SAAS;YACP;gBACEC,MAAMC,0BAAc,CAACC,OAAO;gBAC5BJ;YACF;SACD;IACH;AACF;AAQO,SAASF,sBACdO,MAA2B;IAE3BC,IAAAA,mBAAY,EACVD,QACAH,IAAAA,iBAAI,EAAC;QACHF,OAAOO,yBAAa;IACtB,IACA,+EACAC,oBAAS,CAACC,aAAa;AAE3B;AAEO,MAAMV,6BAGT;IACF,CAACI,0BAAc,CAACC,OAAO,CAAC,EAAEM,OAAOC,MAAM,CAAC;QACtCT,MAAMC,0BAAc,CAACC,OAAO;QAC5BQ,WAAW,CAACP,SAAWP,sBAAsBO;QAC7CQ,WAAW,CAACC,QAAQT;YAClB,OAAO,OAAOU;gBACZ,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAwDH;gBACzD,MAAMI,UAAUd,OAAOL,KAAK;gBAC5B,MAAM,EAAEoB,MAAM,EAAE,GAAGJ;gBACnB,IAAI,CAACK,IAAAA,kBAAW,EAACF,SAASC,SAAS;oBACjC,MAAM,IAAIE,MACR,CAAC,EAAEJ,OAAO,oCAAoC,EAAEE,OAAO,MAAM,CAAC;gBAElE;gBACA,OAAO,MAAMN,OAAOC;YACtB;QACF;IACF;AACF"}

package/dist/cjs/restricted/dialog.js

@@ -1,145 +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, {
-    dialogBuilder: function() {
-        return dialogBuilder;
-    },
-    getDialogImplementation: function() {
-        return getDialogImplementation;
-    }
-});
-const _permissioncontroller = require("@metamask/permission-controller");
-const _rpcerrors = require("@metamask/rpc-errors");
-const _snapssdk = require("@metamask/snaps-sdk");
-const _snapsutils = require("@metamask/snaps-utils");
-const _superstruct = require("superstruct");
-const methodName = 'snap_dialog';
-const PlaceholderStruct = (0, _superstruct.optional)((0, _superstruct.size)((0, _superstruct.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: _permissioncontroller.PermissionType.RestrictedMethod,
-        targetName: methodName,
-        allowedCaveats,
-        methodImplementation: getDialogImplementation(methodHooks),
-        subjectTypes: [
-            _permissioncontroller.SubjectType.Snap
-        ]
-    };
-};
-const methodHooks = {
-    showDialog: true,
-    isOnPhishingList: true,
-    maybeUpdatePhishingList: true
-};
-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 = (0, _superstruct.type)({
-    type: (0, _superstruct.enums)([
-        _snapssdk.DialogType.Alert,
-        _snapssdk.DialogType.Confirmation,
-        _snapssdk.DialogType.Prompt
-    ])
-});
-const AlertParametersStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Alert),
-    content: _snapssdk.ComponentStruct
-});
-const ConfirmationParametersStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Confirmation),
-    content: _snapssdk.ComponentStruct
-});
-const PromptParametersStruct = (0, _superstruct.object)({
-    type: (0, _snapssdk.enumValue)(_snapssdk.DialogType.Prompt),
-    content: _snapssdk.ComponentStruct,
-    placeholder: PlaceholderStruct
-});
-const DialogParametersStruct = (0, _superstruct.union)([
-    AlertParametersStruct,
-    ConfirmationParametersStruct,
-    PromptParametersStruct
-]);
-const structs = {
-    [_snapssdk.DialogType.Alert]: AlertParametersStruct,
-    [_snapssdk.DialogType.Confirmation]: ConfirmationParametersStruct,
-    [_snapssdk.DialogType.Prompt]: PromptParametersStruct
-};
-function getDialogImplementation({ showDialog, isOnPhishingList, maybeUpdatePhishingList }) {
-    return async function dialogImplementation(args) {
-        const { params, context: { origin } } = args;
-        const validatedType = getValidatedType(params);
-        const validatedParams = getValidatedParams(params, structs[validatedType]);
-        const { content } = validatedParams;
-        await maybeUpdatePhishingList();
-        (0, _snapsutils.validateComponentLinks)(content, isOnPhishingList);
-        const placeholder = validatedParams.type === _snapssdk.DialogType.Prompt ? validatedParams.placeholder : undefined;
-        return showDialog(origin, validatedType, content, 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 (0, _superstruct.create)(params, BaseParamsStruct).type;
-    } catch (error) {
-        throw _rpcerrors.rpcErrors.invalidParams({
-            message: `The "type" property must be one of: ${Object.values(_snapssdk.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 (0, _superstruct.create)(params, struct);
-    } catch (error) {
-        if (error instanceof _superstruct.StructError) {
-            const { key, type: errorType } = error;
-            if (key === 'placeholder' && errorType === 'never') {
-                throw _rpcerrors.rpcErrors.invalidParams({
-                    message: 'Invalid params: Alerts or confirmations may not specify a "placeholder" field.'
-                });
-            }
-            throw _rpcerrors.rpcErrors.invalidParams({
-                message: `Invalid params: ${error.message}.`
-            });
-        }
-        /* istanbul ignore next */ throw _rpcerrors.rpcErrors.internal();
-    }
-}
-
-//# sourceMappingURL=dialog.js.map