@metamask/snaps-rpc-methods 6.0.0 → 7.0.0

package/dist/chunk-OUD66G6O.mjs

@@ -0,0 +1,74 @@
+// src/endowments/cronjob.ts
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import {
+  SnapCaveatType,
+  isCronjobSpecificationArray
+} from "@metamask/snaps-utils";
+import { assert, hasProperty, isPlainObject } from "@metamask/utils";
+var permissionName = "endowment:cronjob" /* Cronjob */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: [SnapCaveatType.SnapCronjob],
+    endowmentGetter: (_getterOptions) => void 0,
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var cronjobEndowmentBuilder = Object.freeze({
+  targetName: permissionName,
+  specificationBuilder
+});
+function getCronjobCaveatMapper(value) {
+  return {
+    caveats: [
+      {
+        type: SnapCaveatType.SnapCronjob,
+        value
+      }
+    ]
+  };
+}
+function getCronjobCaveatJobs(permission) {
+  if (!permission?.caveats) {
+    return null;
+  }
+  assert(permission.caveats.length === 1);
+  assert(permission.caveats[0].type === SnapCaveatType.SnapCronjob);
+  const caveat = permission.caveats[0];
+  return caveat.value?.jobs ?? null;
+}
+function validateCronjobCaveat(caveat) {
+  if (!hasProperty(caveat, "value") || !isPlainObject(caveat.value)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected a plain object."
+    });
+  }
+  const { value } = caveat;
+  if (!hasProperty(value, "jobs") || !isPlainObject(value)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected a plain object."
+    });
+  }
+  if (!isCronjobSpecificationArray(value.jobs)) {
+    throw rpcErrors.invalidParams({
+      message: "Expected a valid cronjob specification array."
+    });
+  }
+}
+var cronjobCaveatSpecifications = {
+  [SnapCaveatType.SnapCronjob]: Object.freeze({
+    type: SnapCaveatType.SnapCronjob,
+    validator: (caveat) => validateCronjobCaveat(caveat)
+  })
+};
+
+export {
+  cronjobEndowmentBuilder,
+  getCronjobCaveatMapper,
+  getCronjobCaveatJobs,
+  validateCronjobCaveat,
+  cronjobCaveatSpecifications
+};
+//# sourceMappingURL=chunk-OUD66G6O.mjs.map

package/dist/chunk-OUD66G6O.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/cronjob.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n  PermissionConstraint,\n  Caveat,\n  CaveatSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { CronjobSpecification } from '@metamask/snaps-utils';\nimport {\n  SnapCaveatType,\n  isCronjobSpecificationArray,\n} from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isPlainObject } from '@metamask/utils';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.Cronjob;\n\ntype CronjobEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * `endowment:cronjob` returns nothing; it is intended to be used as a flag to determine whether the snap wants to run cronjobs.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the cronjob endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  CronjobEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [SnapCaveatType.SnapCronjob],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const cronjobEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\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 getCronjobCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapCronjob,\n        value,\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the cronjobs from a permission.\n *\n * This does basic validation of the caveat, but does not validate the type or\n * value of the namespaces object itself, as this is handled by the\n * `PermissionsController` when the permission is requested.\n *\n * @param permission - The permission to get the keyring namespaces from.\n * @returns The cronjobs, or `null` if the permission does not have a\n * cronjob caveat.\n */\nexport function getCronjobCaveatJobs(\n  permission?: PermissionConstraint,\n): CronjobSpecification[] | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.SnapCronjob);\n\n  const caveat = permission.caveats[0] as Caveat<string, { jobs: Json[] }>;\n\n  return (caveat.value?.jobs as CronjobSpecification[]) ?? null;\n}\n\n/**\n * Validate the cronjob specification values associated with a caveat.\n * This validates that the value is a non-empty array with valid\n * cronjob expression and request object.\n *\n * @param caveat - The caveat to validate.\n * @throws If the value is invalid.\n */\nexport function validateCronjobCaveat(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat.value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n\n  if (!hasProperty(value, 'jobs') || !isPlainObject(value)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  if (!isCronjobSpecificationArray(value.jobs)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a valid cronjob specification array.',\n    });\n  }\n}\n\n/**\n * Caveat specification for the Cronjob.\n */\nexport const cronjobCaveatSpecifications: Record<\n  SnapCaveatType.SnapCronjob,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.SnapCronjob]: Object.freeze({\n    type: SnapCaveatType.SnapCronjob,\n    validator: (caveat) => validateCronjobCaveat(caveat),\n  }),\n};\n"],"mappings":";AAQA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAE1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,QAAQ,aAAa,qBAAqB;AAInD,IAAM;AAeN,IAAM,uBAIF,CAAC,oBAA0B;AAC7B,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB,CAAC,eAAe,WAAW;AAAA,IAC3C,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,0BAA0B,OAAO,OAAO;AAAA,EACnD,YAAY;AAAA,EACZ;AACF,CAAU;AAUH,SAAS,uBACd,OACuC;AACvC,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAaO,SAAS,qBACd,YAC+B;AAC/B,MAAI,CAAC,YAAY,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,QAAQ,WAAW,CAAC;AACtC,SAAO,WAAW,QAAQ,CAAC,EAAE,SAAS,eAAe,WAAW;AAEhE,QAAM,SAAS,WAAW,QAAQ,CAAC;AAEnC,SAAQ,OAAO,OAAO,QAAmC;AAC3D;AAUO,SAAS,sBAAsB,QAA6B;AACjE,MAAI,CAAC,YAAY,QAAQ,OAAO,KAAK,CAAC,cAAc,OAAO,KAAK,GAAG;AACjE,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAElB,MAAI,CAAC,YAAY,OAAO,MAAM,KAAK,CAAC,cAAc,KAAK,GAAG;AACxD,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,MAAI,CAAC,4BAA4B,MAAM,IAAI,GAAG;AAC5C,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AACF;AAKO,IAAM,8BAGT;AAAA,EACF,CAAC,eAAe,WAAW,GAAG,OAAO,OAAO;AAAA,IAC1C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WAAW,sBAAsB,MAAM;AAAA,EACrD,CAAC;AACH;","names":[]}

package/dist/chunk-PEMZWIHQ.js

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkLU3J2EYEjs = require('./chunk-LU3J2EYE.js');
+
+
+var _chunk632BZ6JYjs = require('./chunk-632BZ6JY.js');
+
+// src/permitted/middleware.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapsutils = require('@metamask/snaps-utils');
+function createSnapsMethodMiddleware(isSnap, hooks) {
+  return async function methodMiddleware(request, response, next, end) {
+    const handler = _chunkLU3J2EYEjs.methodHandlers[request.method];
+    if (handler) {
+      if (String.prototype.startsWith.call(request.method, "snap_") && !isSnap) {
+        return end(_rpcerrors.rpcErrors.methodNotFound());
+      }
+      const { implementation, hookNames } = handler;
+      try {
+        return await implementation(
+          request,
+          response,
+          next,
+          end,
+          _chunk632BZ6JYjs.selectHooks.call(void 0, hooks, hookNames)
+        );
+      } catch (error) {
+        _snapsutils.logError.call(void 0, error);
+        return end(error);
+      }
+    }
+    return next();
+  };
+}
+
+
+
+exports.createSnapsMethodMiddleware = createSnapsMethodMiddleware;
+//# sourceMappingURL=chunk-PEMZWIHQ.js.map

package/dist/chunk-PEMZWIHQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/middleware.ts"],"names":[],"mappings":";;;;;;;;AACA,SAAS,iBAAiB;AAC1B,SAAS,gBAAgB;AAalB,SAAS,4BACd,QACA,OACwC;AAGxC,SAAO,eAAe,iBAAiB,SAAS,UAAU,MAAM,KAAK;AACnE,UAAM,UACJ,eAAe,QAAQ,MAAqC;AAC9D,QAAI,SAAS;AACX,UACE,OAAO,UAAU,WAAW,KAAK,QAAQ,QAAQ,OAAO,KACxD,CAAC,QACD;AACA,eAAO,IAAI,UAAU,eAAe,CAAC;AAAA,MACvC;AAGA,YAAM,EAAE,gBAAgB,UAAU,IAAI;AACtC,UAAI;AAEF,eAAO,MAAM;AAAA,UACX;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,YAAY,OAAO,SAAS;AAAA,QAC9B;AAAA,MACF,SAAS,OAAO;AACd,iBAAS,KAAK;AACd,eAAO,IAAI,KAAK;AAAA,MAClB;AAAA,IACF;AAEA,WAAO,KAAK;AAAA,EACd;AACF","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"]}

package/dist/chunk-PSAM7MJM.mjs

@@ -0,0 +1,78 @@
+import {
+  getNode
+} from "./chunk-DR63Z4PV.mjs";
+
+// src/restricted/getBip32PublicKey.ts
+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";
+var targetName = "snap_getBip32PublicKey";
+var Bip32PublicKeyArgsStruct = bip32entropy(
+  object({
+    path: Bip32PathStruct,
+    curve: enums(["ed25519", "secp256k1"]),
+    compressed: optional(boolean())
+  })
+);
+var specificationBuilder = ({ methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: PermissionType.RestrictedMethod,
+    targetName,
+    allowedCaveats: [SnapCaveatType.PermittedDerivationPaths],
+    methodImplementation: getBip32PublicKeyImplementation(methodHooks2),
+    validator: ({ caveats }) => {
+      if (caveats?.length !== 1 || caveats[0].type !== SnapCaveatType.PermittedDerivationPaths) {
+        throw rpcErrors.invalidParams({
+          message: `Expected a single "${SnapCaveatType.PermittedDerivationPaths}" caveat.`
+        });
+      }
+    },
+    subjectTypes: [SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  getMnemonic: true,
+  getUnlockPromise: true
+};
+var getBip32PublicKeyBuilder = Object.freeze({
+  targetName,
+  specificationBuilder,
+  methodHooks
+});
+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;
+  };
+}
+
+export {
+  Bip32PublicKeyArgsStruct,
+  getBip32PublicKeyBuilder,
+  getBip32PublicKeyImplementation
+};
+//# sourceMappingURL=chunk-PSAM7MJM.mjs.map

package/dist/chunk-PSAM7MJM.mjs.map

@@ -0,0 +1 @@
+{"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"],"mappings":";;;;;AAMA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,iBAAiB;AAK1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,oBAAoB;AAC7B,SAAS,SAAS,OAAO,QAAQ,gBAAgB;AAKjD,IAAM,aAAa;AA4BZ,IAAM,2BAA2B;AAAA,EACtC,OAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO,MAAM,CAAC,WAAW,WAAW,CAAC;AAAA,IACrC,YAAY,SAAS,QAAQ,CAAC;AAAA,EAChC,CAAC;AACH;AAWA,IAAM,uBAIF,CAAC,EAAE,aAAAA,aAAY,MAAoD;AACrE,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA,gBAAgB,CAAC,eAAe,wBAAwB;AAAA,IACxD,sBAAsB,gCAAgCA,YAAW;AAAA,IACjE,WAAW,CAAC,EAAE,QAAQ,MAAM;AAC1B,UACE,SAAS,WAAW,KACpB,QAAQ,CAAC,EAAE,SAAS,eAAe,0BACnC;AACA,cAAM,UAAU,cAAc;AAAA,UAC5B,SAAS,sBAAsB,eAAe,wBAAwB;AAAA,QACxE,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAA+D;AAAA,EACnE,aAAa;AAAA,EACb,kBAAkB;AACpB;AAEO,IAAM,2BAA2B,OAAO,OAAO;AAAA,EACpD;AAAA,EACA;AAAA,EACA;AACF,CAAU;AAYH,SAAS,gCAAgC;AAAA,EAC9C;AAAA,EACA;AACF,GAAiC;AAC/B,SAAO,eAAe,kBACpB,MACkC;AAClC,UAAM,iBAAiB,IAAI;AAE3B;AAAA,MACE,KAAK;AAAA,MACL;AAAA,MACA;AAAA,MACA,UAAU;AAAA,IACZ;AAEA,UAAM,EAAE,OAAO,IAAI;AACnB,UAAM,OAAO,MAAM,QAAQ;AAAA,MACzB,OAAO,OAAO;AAAA,MACd,MAAM,OAAO;AAAA,MACb,sBAAsB,MAAM,YAAY;AAAA,IAC1C,CAAC;AAED,QAAI,OAAO,YAAY;AACrB,aAAO,KAAK;AAAA,IACd;AAEA,WAAO,KAAK;AAAA,EACd;AACF;","names":["methodHooks"]}

package/dist/chunk-RC7LBS3H.js

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/endowments/caveats/generic.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+function createGenericPermissionValidator(caveatsToValidate) {
+  const validCaveatTypes = new Set(
+    caveatsToValidate.map((caveat) => caveat.type)
+  );
+  const requiredCaveats = caveatsToValidate.filter(
+    (caveat) => !caveat.optional
+  );
+  return function({ caveats }) {
+    const actualCaveats = _nullishCoalesce(caveats, () => ( []));
+    const passedCaveatTypes = actualCaveats.map((caveat) => caveat.type);
+    const passedCaveatsSet = new Set(passedCaveatTypes);
+    if (passedCaveatsSet.size !== passedCaveatTypes.length) {
+      throw _rpcerrors.rpcErrors.invalidParams({
+        message: "Duplicate caveats are not allowed."
+      });
+    }
+    if (!actualCaveats.every((caveat) => validCaveatTypes.has(caveat.type))) {
+      throw _rpcerrors.rpcErrors.invalidParams({
+        message: `Expected the following caveats: ${caveatsToValidate.map((caveat) => `"${caveat.type}"`).join(", ")}, received ${actualCaveats.map((caveat) => `"${caveat.type}"`).join(", ")}.`
+      });
+    }
+    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {
+      throw _rpcerrors.rpcErrors.invalidParams({
+        message: `Expected the following caveats: ${requiredCaveats.map((caveat) => `"${caveat.type}"`).join(", ")}.`
+      });
+    }
+  };
+}
+
+
+
+exports.createGenericPermissionValidator = createGenericPermissionValidator;
+//# sourceMappingURL=chunk-RC7LBS3H.js.map

package/dist/chunk-RC7LBS3H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/caveats/generic.ts"],"names":[],"mappings":";AAIA,SAAS,iBAAiB;AAkBnB,SAAS,iCACd,mBAI+B;AAC/B,QAAM,mBAAmB,IAAI;AAAA,IAC3B,kBAAkB,IAAI,CAAC,WAAW,OAAO,IAAI;AAAA,EAC/C;AACA,QAAM,kBAAkB,kBAAkB;AAAA,IACxC,CAAC,WAAW,CAAC,OAAO;AAAA,EACtB;AAEA,SAAO,SAAU,EAAE,QAAQ,GAAG;AAC5B,UAAM,gBAAgB,WAAW,CAAC;AAClC,UAAM,oBAAoB,cAAc,IAAI,CAAC,WAAW,OAAO,IAAI;AACnE,UAAM,mBAAmB,IAAI,IAAI,iBAAiB;AAGlD,QAAI,iBAAiB,SAAS,kBAAkB,QAAQ;AACtD,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,cAAc,MAAM,CAAC,WAAW,iBAAiB,IAAI,OAAO,IAAI,CAAC,GAAG;AACvE,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mCAAmC,kBACzC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC,cAAc,cACxB,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,gBAAgB,MAAM,CAAC,WAAW,iBAAiB,IAAI,OAAO,IAAI,CAAC,GAAG;AACzE,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mCAAmC,gBACzC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAAA,EACF;AACF","sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionValidatorConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { Json } from '@metamask/utils';\n\nexport type CaveatMapperReturnValue = Pick<PermissionConstraint, 'caveats'>;\n\nexport type CaveatMapperFunction = (value: Json) => CaveatMapperReturnValue;\n\n/**\n * Create a generic permission validator that validates the presence of certain caveats.\n *\n * This validator only validates the types of the caveats, not the values.\n *\n * @param caveatsToValidate - A list of objects that represent caveats.\n * @param caveatsToValidate.type - The string defining the caveat type.\n * @param caveatsToValidate.optional - An optional boolean flag that defines\n * whether the caveat is optional or not.\n * @returns A function that validates a permission.\n */\nexport function createGenericPermissionValidator(\n  caveatsToValidate: {\n    type: string;\n    optional?: boolean;\n  }[],\n): PermissionValidatorConstraint {\n  const validCaveatTypes = new Set(\n    caveatsToValidate.map((caveat) => caveat.type),\n  );\n  const requiredCaveats = caveatsToValidate.filter(\n    (caveat) => !caveat.optional,\n  );\n\n  return function ({ caveats }) {\n    const actualCaveats = caveats ?? [];\n    const passedCaveatTypes = actualCaveats.map((caveat) => caveat.type);\n    const passedCaveatsSet = new Set(passedCaveatTypes);\n\n    // Disallow duplicates\n    if (passedCaveatsSet.size !== passedCaveatTypes.length) {\n      throw rpcErrors.invalidParams({\n        message: 'Duplicate caveats are not allowed.',\n      });\n    }\n\n    // Disallow caveats that don't match expected types\n    if (!actualCaveats.every((caveat) => validCaveatTypes.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${caveatsToValidate\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}, received ${actualCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n\n    // Fail if not all required caveats are specified\n    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${requiredCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n  };\n}\n"]}

package/dist/chunk-RHGOSBUT.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/endowments/home-page.ts
+var _permissioncontroller = require('@metamask/permission-controller');
+var permissionName = "endowment:page-home" /* HomePage */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: null,
+    endowmentGetter: (_getterOptions) => void 0,
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var homePageEndowmentBuilder = Object.freeze({
+  targetName: permissionName,
+  specificationBuilder
+});
+
+
+
+exports.homePageEndowmentBuilder = homePageEndowmentBuilder;
+//# sourceMappingURL=chunk-RHGOSBUT.js.map

package/dist/chunk-RHGOSBUT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/home-page.ts"],"names":[],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAK5C,IAAM;AAiBN,IAAM,uBAIF,CAAC,oBAA8B;AACjC,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,iBAAiB,CAAC,mBAA2C;AAAA,IAC7D,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,2BAA2B,OAAO,OAAO;AAAA,EACpD,YAAY;AAAA,EACZ;AACF,CAAU","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.HomePage;\n\ntype HomePageEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * `endowment:page-home` returns nothing; it is intended to be used as a\n * flag by the snap controller to detect whether the snap has the capability to\n * use the snap home page feature.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the `snap-pages` endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  HomePageEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const homePageEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"]}

package/dist/chunk-RKCEAMYH.mjs

@@ -0,0 +1,18 @@
+// src/permitted/getSnaps.ts
+var hookNames = {
+  getSnaps: true
+};
+var getSnapsHandler = {
+  methodNames: ["wallet_getSnaps"],
+  implementation: getSnapsImplementation,
+  hookNames
+};
+async function getSnapsImplementation(_req, res, _next, end, { getSnaps }) {
+  res.result = await getSnaps();
+  return end();
+}
+
+export {
+  getSnapsHandler
+};
+//# sourceMappingURL=chunk-RKCEAMYH.mjs.map

package/dist/chunk-RKCEAMYH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/getSnaps.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport type { GetSnapsResult } from '@metamask/snaps-sdk';\nimport type { JsonRpcParams, PendingJsonRpcResponse } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetSnapsHooks> = {\n  getSnaps: true,\n};\n\n/**\n * `wallet_getSnaps` gets the requester's permitted and installed Snaps.\n */\nexport const getSnapsHandler: PermittedHandlerExport<\n  GetSnapsHooks,\n  JsonRpcParams,\n  GetSnapsResult\n> = {\n  methodNames: ['wallet_getSnaps'],\n  implementation: getSnapsImplementation,\n  hookNames,\n};\n\nexport type GetSnapsHooks = {\n  /**\n   * @returns The permitted and installed snaps for the requesting origin.\n   */\n  getSnaps: () => Promise<GetSnapsResult>;\n};\n\n/**\n * The `wallet_getSnaps` method implementation.\n * Fetches available snaps for the requesting origin and adds them to the JSON-RPC response.\n *\n * @param _req - The JSON-RPC request object. Not used by this function.\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.getSnaps - A function that returns the snaps available for the requesting origin.\n * @returns Nothing.\n */\nasync function getSnapsImplementation(\n  _req: unknown,\n  res: PendingJsonRpcResponse<GetSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnaps }: GetSnapsHooks,\n): Promise<void> {\n  // getSnaps is already bound to the origin\n  res.result = await getSnaps();\n  return end();\n}\n"],"mappings":";AAOA,IAAM,YAA8C;AAAA,EAClD,UAAU;AACZ;AAKO,IAAM,kBAIT;AAAA,EACF,aAAa,CAAC,iBAAiB;AAAA,EAC/B,gBAAgB;AAAA,EAChB;AACF;AAsBA,eAAe,uBACb,MACA,KACA,OACA,KACA,EAAE,SAAS,GACI;AAEf,MAAI,SAAS,MAAM,SAAS;AAC5B,SAAO,IAAI;AACb;","names":[]}

package/dist/chunk-RWLBQVYX.mjs

@@ -0,0 +1,73 @@
+// src/endowments/caveats/requestTime.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+import { MaxRequestTimeStruct, SnapCaveatType } from "@metamask/snaps-utils";
+import { assertStruct, hasProperty, isObject } from "@metamask/utils";
+function assertIsMaxRequestTime(value, ErrorWrapper) {
+  assertStruct(
+    value,
+    MaxRequestTimeStruct,
+    "Invalid maxRequestTime",
+    ErrorWrapper
+  );
+}
+function validateMaxRequestTimeCaveat(caveat) {
+  if (!hasProperty(caveat, "value")) {
+    throw rpcErrors.invalidParams({
+      message: "Invalid maxRequestTime caveat."
+    });
+  }
+  const { value } = caveat;
+  assertIsMaxRequestTime(value, rpcErrors.invalidParams);
+}
+function getMaxRequestTimeCaveatMapper(value) {
+  if (!value || !isObject(value) || isObject(value) && !hasProperty(value, "maxRequestTime")) {
+    return { caveats: null };
+  }
+  return {
+    caveats: [
+      {
+        type: SnapCaveatType.MaxRequestTime,
+        value: value.maxRequestTime
+      }
+    ]
+  };
+}
+function createMaxRequestTimeMapper(mapper) {
+  return function(value) {
+    const { maxRequestTime, ...rest } = value;
+    const mapperResult = mapper(rest);
+    if (!maxRequestTime) {
+      return mapperResult;
+    }
+    return {
+      ...mapperResult,
+      caveats: [
+        ...mapperResult.caveats ?? [],
+        {
+          type: SnapCaveatType.MaxRequestTime,
+          value: maxRequestTime
+        }
+      ]
+    };
+  };
+}
+function getMaxRequestTimeCaveat(permission) {
+  const foundCaveat = permission?.caveats?.find(
+    (caveat) => caveat.type === SnapCaveatType.MaxRequestTime
+  );
+  return foundCaveat?.value ?? null;
+}
+var maxRequestTimeCaveatSpecifications = {
+  [SnapCaveatType.MaxRequestTime]: Object.freeze({
+    type: SnapCaveatType.MaxRequestTime,
+    validator: (caveat) => validateMaxRequestTimeCaveat(caveat)
+  })
+};
+
+export {
+  getMaxRequestTimeCaveatMapper,
+  createMaxRequestTimeMapper,
+  getMaxRequestTimeCaveat,
+  maxRequestTimeCaveatSpecifications
+};
+//# sourceMappingURL=chunk-RWLBQVYX.mjs.map

package/dist/chunk-RWLBQVYX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/caveats/requestTime.ts"],"sourcesContent":["import type {\n  Caveat,\n  CaveatSpecificationConstraint,\n  PermissionConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { MaxRequestTimeStruct, SnapCaveatType } from '@metamask/snaps-utils';\nimport type { AssertionErrorConstructor, Json } from '@metamask/utils';\nimport { assertStruct, hasProperty, isObject } from '@metamask/utils';\n\nimport type { CaveatMapperFunction, CaveatMapperReturnValue } from './generic';\n\n/**\n * Asserts that the given value is a valid `maxRequestTime` value.\n *\n * @param value - The value to assert.\n * @param ErrorWrapper - An optional error wrapper to use. Defaults to\n * {@link AssertionError}.\n * @throws If the value is not a valid `maxRequestTime` value.\n */\nfunction assertIsMaxRequestTime(\n  value: unknown, // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is number {\n  assertStruct(\n    value,\n    MaxRequestTimeStruct,\n    'Invalid maxRequestTime',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Validate the value of a caveat. This does not validate the type of the\n * caveat itself, only the value of the caveat.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateMaxRequestTimeCaveat(caveat: Caveat<string, any>) {\n  if (!hasProperty(caveat, 'value')) {\n    throw rpcErrors.invalidParams({\n      message: 'Invalid maxRequestTime caveat.',\n    });\n  }\n\n  const { value } = caveat;\n  assertIsMaxRequestTime(value, rpcErrors.invalidParams);\n}\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 getMaxRequestTimeCaveatMapper(\n  value: Json,\n): CaveatMapperReturnValue {\n  if (\n    !value ||\n    !isObject(value) ||\n    (isObject(value) && !hasProperty(value, 'maxRequestTime'))\n  ) {\n    return { caveats: null };\n  }\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.MaxRequestTime,\n        value: value.maxRequestTime,\n      },\n    ],\n  };\n}\n\n/**\n * Creates a wrapping caveat mapper that creates the `maxRequestTime` caveat\n * and merges it with any other caveats created by the mapper function.\n *\n * @param mapper - Another caveat mapper function.\n * @returns The caveat specification.\n */\nexport function createMaxRequestTimeMapper(\n  mapper: CaveatMapperFunction,\n): CaveatMapperFunction {\n  return function (value: Json) {\n    // We assume this to be used only with caveats of this type\n    const { maxRequestTime, ...rest } = value as Record<string, Json>;\n\n    const mapperResult = mapper(rest);\n\n    if (!maxRequestTime) {\n      return mapperResult;\n    }\n\n    return {\n      ...mapperResult,\n      caveats: [\n        ...(mapperResult.caveats ?? []),\n        {\n          type: SnapCaveatType.MaxRequestTime,\n          value: maxRequestTime,\n        },\n      ],\n    };\n  };\n}\n\n/**\n * Getter function to get the {@link MaxRequestTime} caveat value from a permission if specified.\n *\n * @param permission - The permission to get the caveat value from.\n * @returns The caveat value if present, otherwise null.\n */\nexport function getMaxRequestTimeCaveat(\n  permission?: PermissionConstraint,\n): number | null {\n  const foundCaveat = permission?.caveats?.find(\n    (caveat) => caveat.type === SnapCaveatType.MaxRequestTime,\n  );\n  return (foundCaveat?.value as number) ?? null;\n}\n\nexport const maxRequestTimeCaveatSpecifications: Record<\n  SnapCaveatType.MaxRequestTime,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.MaxRequestTime]: Object.freeze({\n    type: SnapCaveatType.MaxRequestTime,\n    validator: (caveat: Caveat<string, any>) =>\n      validateMaxRequestTimeCaveat(caveat),\n  }),\n};\n"],"mappings":";AAKA,SAAS,iBAAiB;AAC1B,SAAS,sBAAsB,sBAAsB;AAErD,SAAS,cAAc,aAAa,gBAAgB;AAYpD,SAAS,uBACP,OACA,cACyB;AACzB;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AASA,SAAS,6BAA6B,QAA6B;AACjE,MAAI,CAAC,YAAY,QAAQ,OAAO,GAAG;AACjC,UAAM,UAAU,cAAc;AAAA,MAC5B,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AAEA,QAAM,EAAE,MAAM,IAAI;AAClB,yBAAuB,OAAO,UAAU,aAAa;AACvD;AAUO,SAAS,8BACd,OACyB;AACzB,MACE,CAAC,SACD,CAAC,SAAS,KAAK,KACd,SAAS,KAAK,KAAK,CAAC,YAAY,OAAO,gBAAgB,GACxD;AACA,WAAO,EAAE,SAAS,KAAK;AAAA,EACzB;AACA,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,QACE,MAAM,eAAe;AAAA,QACrB,OAAO,MAAM;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACF;AASO,SAAS,2BACd,QACsB;AACtB,SAAO,SAAU,OAAa;AAE5B,UAAM,EAAE,gBAAgB,GAAG,KAAK,IAAI;AAEpC,UAAM,eAAe,OAAO,IAAI;AAEhC,QAAI,CAAC,gBAAgB;AACnB,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,MACL,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAI,aAAa,WAAW,CAAC;AAAA,QAC7B;AAAA,UACE,MAAM,eAAe;AAAA,UACrB,OAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,wBACd,YACe;AACf,QAAM,cAAc,YAAY,SAAS;AAAA,IACvC,CAAC,WAAW,OAAO,SAAS,eAAe;AAAA,EAC7C;AACA,SAAQ,aAAa,SAAoB;AAC3C;AAEO,IAAM,qCAGT;AAAA,EACF,CAAC,eAAe,cAAc,GAAG,OAAO,OAAO;AAAA,IAC7C,MAAM,eAAe;AAAA,IACrB,WAAW,CAAC,WACV,6BAA6B,MAAM;AAAA,EACvC,CAAC;AACH;","names":[]}

package/dist/chunk-RZDRHJXI.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/endowments/web-assembly.ts
+var _permissioncontroller = require('@metamask/permission-controller');
+var permissionName = "endowment:webassembly" /* WebAssemblyAccess */;
+var specificationBuilder = (_builderOptions) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.Endowment,
+    targetName: permissionName,
+    allowedCaveats: null,
+    endowmentGetter: (_getterOptions) => {
+      return ["WebAssembly"];
+    },
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var webAssemblyEndowmentBuilder = Object.freeze({
+  targetName: permissionName,
+  specificationBuilder
+});
+
+
+
+exports.webAssemblyEndowmentBuilder = webAssemblyEndowmentBuilder;
+//# sourceMappingURL=chunk-RZDRHJXI.js.map

package/dist/{cjs/endowments/web-assembly.js.map → chunk-RZDRHJXI.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/endowments/web-assembly.ts"],"sourcesContent":["import type {\n  EndowmentGetterParams,\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.WebAssemblyAccess;\n\ntype WebAssemblyEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => ['WebAssembly'];\n  allowedCaveats: null;\n}>;\n\n/**\n * `endowment:webassembly` returns the name of global browser API(s) that\n * enable access to the WebAssembly API.\n * This is intended to populate the endowments of the SES Compartment\n * in which a Snap executes.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the WebAssembly endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  WebAssemblyEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => {\n      return ['WebAssembly'];\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const webAssemblyEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"names":["webAssemblyEndowmentBuilder","permissionName","SnapEndowments","WebAssemblyAccess","specificationBuilder","_builderOptions","permissionType","PermissionType","Endowment","targetName","allowedCaveats","endowmentGetter","_getterOptions","subjectTypes","SubjectType","Snap","Object","freeze"],"mappings":";;;;+BA2CaA;;;eAAAA;;;sCAtC+B;sBAEb;AAE/B,MAAMC,iBAAiBC,oBAAc,CAACC,iBAAiB;AASvD;;;;;;;;CAQC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,SAAS;QACxCC,YAAYR;QACZS,gBAAgB;QAChBC,iBAAiB,CAACC;YAChB,OAAO;gBAAC;aAAc;QACxB;QACAC,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEO,MAAMf,8BAA8BgB,OAAOC,MAAM,CAAC;IACvDR,YAAYR;IACZG;AACF"}
+{"version":3,"sources":["../src/endowments/web-assembly.ts"],"names":[],"mappings":";AAKA,SAAS,gBAAgB,mBAAmB;AAI5C,IAAM;AAkBN,IAAM,uBAIF,CAAC,oBAA0B;AAC7B,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,iBAAiB,CAAC,mBAA2C;AAC3D,aAAO,CAAC,aAAa;AAAA,IACvB;AAAA,IACA,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,8BAA8B,OAAO,OAAO;AAAA,EACvD,YAAY;AAAA,EACZ;AACF,CAAU","sourcesContent":["import type {\n  EndowmentGetterParams,\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.WebAssemblyAccess;\n\ntype WebAssemblyEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => ['WebAssembly'];\n  allowedCaveats: null;\n}>;\n\n/**\n * `endowment:webassembly` returns the name of global browser API(s) that\n * enable access to the WebAssembly API.\n * This is intended to populate the endowments of the SES Compartment\n * in which a Snap executes.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the WebAssembly endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  WebAssemblyEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => {\n      return ['WebAssembly'];\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const webAssemblyEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"]}

package/dist/chunk-SCXW3FQO.js

@@ -0,0 +1,49 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkJV26U22Gjs = require('./chunk-JV26U22G.js');
+
+
+var _chunk6PXDUIXNjs = require('./chunk-6PXDUIXN.js');
+
+
+var _chunkTNIGT6KNjs = require('./chunk-TNIGT6KN.js');
+
+
+var _chunkTRB2LS4Njs = require('./chunk-TRB2LS4N.js');
+
+
+var _chunkXAQ2P3BYjs = require('./chunk-XAQ2P3BY.js');
+
+
+var _chunkI5H5ZZRCjs = require('./chunk-I5H5ZZRC.js');
+
+
+var _chunk3FKD2O7Mjs = require('./chunk-3FKD2O7M.js');
+
+
+var _chunkFMUQOZIOjs = require('./chunk-FMUQOZIO.js');
+
+
+var _chunkUXVJ7HYOjs = require('./chunk-UXVJ7HYO.js');
+
+
+var _chunkUYSXSKMLjs = require('./chunk-UYSXSKML.js');
+
+// src/restricted/index.ts
+var restrictedMethodPermissionBuilders = {
+  [_chunk3FKD2O7Mjs.dialogBuilder.targetName]: _chunk3FKD2O7Mjs.dialogBuilder,
+  [_chunkFMUQOZIOjs.getBip32EntropyBuilder.targetName]: _chunkFMUQOZIOjs.getBip32EntropyBuilder,
+  [_chunkUXVJ7HYOjs.getBip32PublicKeyBuilder.targetName]: _chunkUXVJ7HYOjs.getBip32PublicKeyBuilder,
+  [_chunkJV26U22Gjs.getBip44EntropyBuilder.targetName]: _chunkJV26U22Gjs.getBip44EntropyBuilder,
+  [_chunk6PXDUIXNjs.getEntropyBuilder.targetName]: _chunk6PXDUIXNjs.getEntropyBuilder,
+  [_chunkUYSXSKMLjs.invokeSnapBuilder.targetName]: _chunkUYSXSKMLjs.invokeSnapBuilder,
+  [_chunkXAQ2P3BYjs.manageStateBuilder.targetName]: _chunkXAQ2P3BYjs.manageStateBuilder,
+  [_chunkI5H5ZZRCjs.notifyBuilder.targetName]: _chunkI5H5ZZRCjs.notifyBuilder,
+  [_chunkTRB2LS4Njs.manageAccountsBuilder.targetName]: _chunkTRB2LS4Njs.manageAccountsBuilder,
+  [_chunkTNIGT6KNjs.getLocaleBuilder.targetName]: _chunkTNIGT6KNjs.getLocaleBuilder
+};
+
+
+
+exports.restrictedMethodPermissionBuilders = restrictedMethodPermissionBuilders;
+//# sourceMappingURL=chunk-SCXW3FQO.js.map

package/dist/chunk-SCXW3FQO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCO,IAAM,qCAAqC;AAAA,EAChD,CAAC,cAAc,UAAU,GAAG;AAAA,EAC5B,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,yBAAyB,UAAU,GAAG;AAAA,EACvC,CAAC,uBAAuB,UAAU,GAAG;AAAA,EACrC,CAAC,kBAAkB,UAAU,GAAG;AAAA,EAChC,CAAC,kBAAkB,UAAU,GAAG;AAAA,EAChC,CAAC,mBAAmB,UAAU,GAAG;AAAA,EACjC,CAAC,cAAc,UAAU,GAAG;AAAA,EAC5B,CAAC,sBAAsB,UAAU,GAAG;AAAA,EACpC,CAAC,iBAAiB,UAAU,GAAG;AACjC","sourcesContent":["import type { DialogMethodHooks } from './dialog';\nimport { dialogBuilder } from './dialog';\nimport type { GetBip32EntropyMethodHooks } from './getBip32Entropy';\nimport { getBip32EntropyBuilder } from './getBip32Entropy';\nimport type { GetBip32PublicKeyMethodHooks } from './getBip32PublicKey';\nimport { getBip32PublicKeyBuilder } from './getBip32PublicKey';\nimport type { GetBip44EntropyMethodHooks } from './getBip44Entropy';\nimport { getBip44EntropyBuilder } from './getBip44Entropy';\nimport type { GetEntropyHooks } from './getEntropy';\nimport { getEntropyBuilder } from './getEntropy';\nimport type { GetLocaleMethodHooks } from './getLocale';\nimport { getLocaleBuilder } from './getLocale';\nimport type { InvokeSnapMethodHooks } from './invokeSnap';\nimport { invokeSnapBuilder } from './invokeSnap';\nimport type { ManageAccountsMethodHooks } from './manageAccounts';\nimport { manageAccountsBuilder } from './manageAccounts';\nimport type { ManageStateMethodHooks } from './manageState';\nimport { manageStateBuilder } from './manageState';\nimport type { NotifyMethodHooks } from './notify';\nimport { notifyBuilder } from './notify';\n\nexport { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';\nexport { getEncryptionKey } from './manageState';\n\nexport type RestrictedMethodHooks = DialogMethodHooks &\n  GetBip32EntropyMethodHooks &\n  GetBip32PublicKeyMethodHooks &\n  GetBip44EntropyMethodHooks &\n  GetEntropyHooks &\n  InvokeSnapMethodHooks &\n  ManageStateMethodHooks &\n  NotifyMethodHooks &\n  ManageAccountsMethodHooks &\n  GetLocaleMethodHooks;\n\nexport const restrictedMethodPermissionBuilders = {\n  [dialogBuilder.targetName]: dialogBuilder,\n  [getBip32EntropyBuilder.targetName]: getBip32EntropyBuilder,\n  [getBip32PublicKeyBuilder.targetName]: getBip32PublicKeyBuilder,\n  [getBip44EntropyBuilder.targetName]: getBip44EntropyBuilder,\n  [getEntropyBuilder.targetName]: getEntropyBuilder,\n  [invokeSnapBuilder.targetName]: invokeSnapBuilder,\n  [manageStateBuilder.targetName]: manageStateBuilder,\n  [notifyBuilder.targetName]: notifyBuilder,\n  [manageAccountsBuilder.targetName]: manageAccountsBuilder,\n  [getLocaleBuilder.targetName]: getLocaleBuilder,\n} as const;\n\nexport * from './caveats';\n"]}

package/dist/chunk-SMWKMPHG.mjs

@@ -0,0 +1,35 @@
+// src/endowments/caveats/generic.ts
+import { rpcErrors } from "@metamask/rpc-errors";
+function createGenericPermissionValidator(caveatsToValidate) {
+  const validCaveatTypes = new Set(
+    caveatsToValidate.map((caveat) => caveat.type)
+  );
+  const requiredCaveats = caveatsToValidate.filter(
+    (caveat) => !caveat.optional
+  );
+  return function({ caveats }) {
+    const actualCaveats = caveats ?? [];
+    const passedCaveatTypes = actualCaveats.map((caveat) => caveat.type);
+    const passedCaveatsSet = new Set(passedCaveatTypes);
+    if (passedCaveatsSet.size !== passedCaveatTypes.length) {
+      throw rpcErrors.invalidParams({
+        message: "Duplicate caveats are not allowed."
+      });
+    }
+    if (!actualCaveats.every((caveat) => validCaveatTypes.has(caveat.type))) {
+      throw rpcErrors.invalidParams({
+        message: `Expected the following caveats: ${caveatsToValidate.map((caveat) => `"${caveat.type}"`).join(", ")}, received ${actualCaveats.map((caveat) => `"${caveat.type}"`).join(", ")}.`
+      });
+    }
+    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {
+      throw rpcErrors.invalidParams({
+        message: `Expected the following caveats: ${requiredCaveats.map((caveat) => `"${caveat.type}"`).join(", ")}.`
+      });
+    }
+  };
+}
+
+export {
+  createGenericPermissionValidator
+};
+//# sourceMappingURL=chunk-SMWKMPHG.mjs.map

package/dist/chunk-SMWKMPHG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endowments/caveats/generic.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionValidatorConstraint,\n} from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { Json } from '@metamask/utils';\n\nexport type CaveatMapperReturnValue = Pick<PermissionConstraint, 'caveats'>;\n\nexport type CaveatMapperFunction = (value: Json) => CaveatMapperReturnValue;\n\n/**\n * Create a generic permission validator that validates the presence of certain caveats.\n *\n * This validator only validates the types of the caveats, not the values.\n *\n * @param caveatsToValidate - A list of objects that represent caveats.\n * @param caveatsToValidate.type - The string defining the caveat type.\n * @param caveatsToValidate.optional - An optional boolean flag that defines\n * whether the caveat is optional or not.\n * @returns A function that validates a permission.\n */\nexport function createGenericPermissionValidator(\n  caveatsToValidate: {\n    type: string;\n    optional?: boolean;\n  }[],\n): PermissionValidatorConstraint {\n  const validCaveatTypes = new Set(\n    caveatsToValidate.map((caveat) => caveat.type),\n  );\n  const requiredCaveats = caveatsToValidate.filter(\n    (caveat) => !caveat.optional,\n  );\n\n  return function ({ caveats }) {\n    const actualCaveats = caveats ?? [];\n    const passedCaveatTypes = actualCaveats.map((caveat) => caveat.type);\n    const passedCaveatsSet = new Set(passedCaveatTypes);\n\n    // Disallow duplicates\n    if (passedCaveatsSet.size !== passedCaveatTypes.length) {\n      throw rpcErrors.invalidParams({\n        message: 'Duplicate caveats are not allowed.',\n      });\n    }\n\n    // Disallow caveats that don't match expected types\n    if (!actualCaveats.every((caveat) => validCaveatTypes.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${caveatsToValidate\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}, received ${actualCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n\n    // Fail if not all required caveats are specified\n    if (!requiredCaveats.every((caveat) => passedCaveatsSet.has(caveat.type))) {\n      throw rpcErrors.invalidParams({\n        message: `Expected the following caveats: ${requiredCaveats\n          .map((caveat) => `\"${caveat.type}\"`)\n          .join(', ')}.`,\n      });\n    }\n  };\n}\n"],"mappings":";AAIA,SAAS,iBAAiB;AAkBnB,SAAS,iCACd,mBAI+B;AAC/B,QAAM,mBAAmB,IAAI;AAAA,IAC3B,kBAAkB,IAAI,CAAC,WAAW,OAAO,IAAI;AAAA,EAC/C;AACA,QAAM,kBAAkB,kBAAkB;AAAA,IACxC,CAAC,WAAW,CAAC,OAAO;AAAA,EACtB;AAEA,SAAO,SAAU,EAAE,QAAQ,GAAG;AAC5B,UAAM,gBAAgB,WAAW,CAAC;AAClC,UAAM,oBAAoB,cAAc,IAAI,CAAC,WAAW,OAAO,IAAI;AACnE,UAAM,mBAAmB,IAAI,IAAI,iBAAiB;AAGlD,QAAI,iBAAiB,SAAS,kBAAkB,QAAQ;AACtD,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,cAAc,MAAM,CAAC,WAAW,iBAAiB,IAAI,OAAO,IAAI,CAAC,GAAG;AACvE,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mCAAmC,kBACzC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC,cAAc,cACxB,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,gBAAgB,MAAM,CAAC,WAAW,iBAAiB,IAAI,OAAO,IAAI,CAAC,GAAG;AACzE,YAAM,UAAU,cAAc;AAAA,QAC5B,SAAS,mCAAmC,gBACzC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,GAAG,EAClC,KAAK,IAAI,CAAC;AAAA,MACf,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-SXSNJEE7.js

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/permitted/getSnaps.ts
+var hookNames = {
+  getSnaps: true
+};
+var getSnapsHandler = {
+  methodNames: ["wallet_getSnaps"],
+  implementation: getSnapsImplementation,
+  hookNames
+};
+async function getSnapsImplementation(_req, res, _next, end, { getSnaps }) {
+  res.result = await getSnaps();
+  return end();
+}
+
+
+
+exports.getSnapsHandler = getSnapsHandler;
+//# sourceMappingURL=chunk-SXSNJEE7.js.map

package/dist/chunk-SXSNJEE7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/permitted/getSnaps.ts"],"names":[],"mappings":";AAOA,IAAM,YAA8C;AAAA,EAClD,UAAU;AACZ;AAKO,IAAM,kBAIT;AAAA,EACF,aAAa,CAAC,iBAAiB;AAAA,EAC/B,gBAAgB;AAAA,EAChB;AACF;AAsBA,eAAe,uBACb,MACA,KACA,OACA,KACA,EAAE,SAAS,GACI;AAEf,MAAI,SAAS,MAAM,SAAS;AAC5B,SAAO,IAAI;AACb","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport type { GetSnapsResult } from '@metamask/snaps-sdk';\nimport type { JsonRpcParams, PendingJsonRpcResponse } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetSnapsHooks> = {\n  getSnaps: true,\n};\n\n/**\n * `wallet_getSnaps` gets the requester's permitted and installed Snaps.\n */\nexport const getSnapsHandler: PermittedHandlerExport<\n  GetSnapsHooks,\n  JsonRpcParams,\n  GetSnapsResult\n> = {\n  methodNames: ['wallet_getSnaps'],\n  implementation: getSnapsImplementation,\n  hookNames,\n};\n\nexport type GetSnapsHooks = {\n  /**\n   * @returns The permitted and installed snaps for the requesting origin.\n   */\n  getSnaps: () => Promise<GetSnapsResult>;\n};\n\n/**\n * The `wallet_getSnaps` method implementation.\n * Fetches available snaps for the requesting origin and adds them to the JSON-RPC response.\n *\n * @param _req - The JSON-RPC request object. Not used by this function.\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.getSnaps - A function that returns the snaps available for the requesting origin.\n * @returns Nothing.\n */\nasync function getSnapsImplementation(\n  _req: unknown,\n  res: PendingJsonRpcResponse<GetSnapsResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnaps }: GetSnapsHooks,\n): Promise<void> {\n  // getSnaps is already bound to the origin\n  res.result = await getSnaps();\n  return end();\n}\n"]}

package/dist/chunk-TNIGT6KN.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/restricted/getLocale.ts
+var _permissioncontroller = require('@metamask/permission-controller');
+var methodName = "snap_getLocale";
+var specificationBuilder = ({ allowedCaveats = null, methodHooks: methodHooks2 }) => {
+  return {
+    permissionType: _permissioncontroller.PermissionType.RestrictedMethod,
+    targetName: methodName,
+    allowedCaveats,
+    methodImplementation: getImplementation(methodHooks2),
+    subjectTypes: [_permissioncontroller.SubjectType.Snap]
+  };
+};
+var methodHooks = {
+  getLocale: true
+};
+var getLocaleBuilder = Object.freeze({
+  targetName: methodName,
+  specificationBuilder,
+  methodHooks
+});
+function getImplementation({ getLocale }) {
+  return async function implementation(_args) {
+    return getLocale();
+  };
+}
+
+
+
+
+
+exports.specificationBuilder = specificationBuilder; exports.getLocaleBuilder = getLocaleBuilder; exports.getImplementation = getImplementation;
+//# sourceMappingURL=chunk-TNIGT6KN.js.map

package/dist/chunk-TNIGT6KN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/restricted/getLocale.ts"],"names":["methodHooks"],"mappings":";AAMA,SAAS,gBAAgB,mBAAmB;AAM5C,IAAM,aAAa;AA2BZ,IAAM,uBAIT,CAAC,EAAE,iBAAiB,MAAM,aAAAA,aAAY,MAAmC;AAC3E,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B,YAAY;AAAA,IACZ;AAAA,IACA,sBAAsB,kBAAkBA,YAAW;AAAA,IACnD,cAAc,CAAC,YAAY,IAAI;AAAA,EACjC;AACF;AAEA,IAAM,cAAuD;AAAA,EAC3D,WAAW;AACb;AAEO,IAAM,mBAAmB,OAAO,OAAO;AAAA,EAC5C,YAAY;AAAA,EACZ;AAAA,EACA;AACF,CAAU;AASH,SAAS,kBAAkB,EAAE,UAAU,GAAyB;AACrE,SAAO,eAAe,eACpB,OAC0B;AAC1B,WAAO,UAAU;AAAA,EACnB;AACF","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n  RestrictedMethodOptions,\n  RestrictedMethodParameters,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport type { GetLocaleResult } from '@metamask/snaps-sdk';\nimport type { NonEmptyArray } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_getLocale';\n\nexport type GetLocaleMethodHooks = {\n  getLocale: () => Promise<string>;\n};\n\ntype SpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: GetLocaleMethodHooks;\n};\n\ntype Specification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_getLocale` permission.\n * `snap_getLocale` allows snaps to get the user selected locale.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_getLocale` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  SpecificationBuilderOptions,\n  Specification\n> = ({ allowedCaveats = null, methodHooks }: SpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<GetLocaleMethodHooks> = {\n  getLocale: true,\n};\n\nexport const getLocaleBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_getLocale`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.getLocale - A function that returns the user selected locale.\n * @returns The user selected locale.\n */\nexport function getImplementation({ getLocale }: GetLocaleMethodHooks) {\n  return async function implementation(\n    _args: RestrictedMethodOptions<RestrictedMethodParameters>,\n  ): Promise<GetLocaleResult> {\n    return getLocale();\n  };\n}\n"]}