@metamask/snaps-rpc-methods 5.0.0 → 6.0.0

package/dist/cjs/endowments/transaction-insight.js

@@ -0,0 +1,111 @@
+"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, {
+    transactionInsightEndowmentBuilder: function() {
+        return transactionInsightEndowmentBuilder;
+    },
+    getTransactionInsightCaveatMapper: function() {
+        return getTransactionInsightCaveatMapper;
+    },
+    getTransactionOriginCaveat: function() {
+        return getTransactionOriginCaveat;
+    },
+    transactionInsightCaveatSpecifications: function() {
+        return transactionInsightCaveatSpecifications;
+    }
+});
+const _permissioncontroller = require("@metamask/permission-controller");
+const _rpcerrors = require("@metamask/rpc-errors");
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _caveats = require("./caveats");
+const _enum = require("./enum");
+const permissionName = _enum.SnapEndowments.TransactionInsight;
+/**
+ * `endowment:transaction-insight` returns nothing; it is intended to be used as a flag
+ * by the extension to detect whether the snap has the capability to show information on the transaction confirmation screen.
+ *
+ * @param _builderOptions - Optional specification builder options.
+ * @returns The specification for the transaction-insight endowment.
+ */ const specificationBuilder = (_builderOptions)=>{
+    return {
+        permissionType: _permissioncontroller.PermissionType.Endowment,
+        targetName: permissionName,
+        allowedCaveats: [
+            _snapsutils.SnapCaveatType.TransactionOrigin,
+            _snapsutils.SnapCaveatType.MaxRequestTime
+        ],
+        endowmentGetter: (_getterOptions)=>undefined,
+        validator: (0, _caveats.createGenericPermissionValidator)([
+            {
+                type: _snapsutils.SnapCaveatType.TransactionOrigin,
+                optional: true
+            },
+            {
+                type: _snapsutils.SnapCaveatType.MaxRequestTime,
+                optional: true
+            }
+        ]),
+        subjectTypes: [
+            _permissioncontroller.SubjectType.Snap
+        ]
+    };
+};
+const transactionInsightEndowmentBuilder = Object.freeze({
+    targetName: permissionName,
+    specificationBuilder
+});
+/**
+ * Validates the type of the caveat value.
+ *
+ * @param caveat - The caveat to validate.
+ * @throws If the caveat value is invalid.
+ */ function validateCaveat(caveat) {
+    if (!(0, _utils.hasProperty)(caveat, 'value') || !(0, _utils.isPlainObject)(caveat)) {
+        throw _rpcerrors.rpcErrors.invalidParams({
+            message: 'Expected a plain object.'
+        });
+    }
+    const { value } = caveat;
+    (0, _utils.assert)(typeof value === 'boolean', 'Expected caveat value to have type "boolean"');
+}
+function getTransactionInsightCaveatMapper(value) {
+    if (!value || !(0, _utils.isObject)(value) || (0, _utils.isObject)(value) && Object.keys(value).length === 0) {
+        return {
+            caveats: null
+        };
+    }
+    return {
+        caveats: [
+            {
+                type: _snapsutils.SnapCaveatType.TransactionOrigin,
+                value: (0, _utils.hasProperty)(value, 'allowTransactionOrigin') && value.allowTransactionOrigin
+            }
+        ]
+    };
+}
+function getTransactionOriginCaveat(permission) {
+    if (!permission?.caveats) {
+        return null;
+    }
+    (0, _utils.assert)(permission.caveats.length === 1);
+    (0, _utils.assert)(permission.caveats[0].type === _snapsutils.SnapCaveatType.TransactionOrigin);
+    const caveat = permission.caveats[0];
+    return caveat.value ?? null;
+}
+const transactionInsightCaveatSpecifications = {
+    [_snapsutils.SnapCaveatType.TransactionOrigin]: Object.freeze({
+        type: _snapsutils.SnapCaveatType.TransactionOrigin,
+        validator: (caveat)=>validateCaveat(caveat)
+    })
+};
+
+//# sourceMappingURL=transaction-insight.js.map

package/dist/cjs/endowments/transaction-insight.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/endowments/transaction-insight.ts"],"sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  EndowmentGetterParams,\n  ValidPermissionSpecification,\n  PermissionValidatorConstraint,\n  PermissionConstraint,\n  CaveatSpecificationConstraint,\n  Caveat,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { SnapCaveatType } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray } from '@metamask/utils';\nimport { assert, hasProperty, isObject, isPlainObject } from '@metamask/utils';\n\nimport { createGenericPermissionValidator } from './caveats';\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.TransactionInsight;\n\ntype TransactionInsightEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: EndowmentGetterParams) => undefined;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n  validator: PermissionValidatorConstraint;\n}>;\n\n/**\n * `endowment:transaction-insight` returns nothing; it is intended to be used as a flag\n * by the extension to detect whether the snap has the capability to show information on the transaction confirmation screen.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the transaction-insight endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  TransactionInsightEndowmentSpecification\n> = (_builderOptions?: unknown) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: [\n      SnapCaveatType.TransactionOrigin,\n      SnapCaveatType.MaxRequestTime,\n    ],\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => undefined,\n    validator: createGenericPermissionValidator([\n      { type: SnapCaveatType.TransactionOrigin, optional: true },\n      { type: SnapCaveatType.MaxRequestTime, optional: true },\n    ]),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const transactionInsightEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n\n/**\n * Validates the type of the caveat value.\n *\n * @param caveat - The caveat to validate.\n * @throws If the caveat value is invalid.\n */\nfunction validateCaveat(caveat: Caveat<string, any>): void {\n  if (!hasProperty(caveat, 'value') || !isPlainObject(caveat)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected a plain object.',\n    });\n  }\n\n  const { value } = caveat;\n\n  assert(\n    typeof value === 'boolean',\n    'Expected caveat value to have type \"boolean\"',\n  );\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 getTransactionInsightCaveatMapper(\n  value: Json,\n): Pick<PermissionConstraint, 'caveats'> {\n  if (\n    !value ||\n    !isObject(value) ||\n    (isObject(value) && Object.keys(value).length === 0)\n  ) {\n    return { caveats: null };\n  }\n  return {\n    caveats: [\n      {\n        type: SnapCaveatType.TransactionOrigin,\n        value:\n          hasProperty(value, 'allowTransactionOrigin') &&\n          (value.allowTransactionOrigin as boolean),\n      },\n    ],\n  };\n}\n\n/**\n * Getter function to get the transaction origin caveat 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 transaction origin caveat from.\n * @returns The transaction origin, or `null` if the permission does not have a\n * transaction origin caveat.\n */\nexport function getTransactionOriginCaveat(\n  permission?: PermissionConstraint,\n): boolean | null {\n  if (!permission?.caveats) {\n    return null;\n  }\n\n  assert(permission.caveats.length === 1);\n  assert(permission.caveats[0].type === SnapCaveatType.TransactionOrigin);\n\n  const caveat = permission.caveats[0] as Caveat<string, boolean>;\n\n  return caveat.value ?? null;\n}\n\nexport const transactionInsightCaveatSpecifications: Record<\n  SnapCaveatType.TransactionOrigin,\n  CaveatSpecificationConstraint\n> = {\n  [SnapCaveatType.TransactionOrigin]: Object.freeze({\n    type: SnapCaveatType.TransactionOrigin,\n    validator: (caveat: Caveat<string, any>) => validateCaveat(caveat),\n  }),\n};\n"],"names":["transactionInsightEndowmentBuilder","getTransactionInsightCaveatMapper","getTransactionOriginCaveat","transactionInsightCaveatSpecifications","permissionName","SnapEndowments","TransactionInsight","specificationBuilder","_builderOptions","permissionType","PermissionType","Endowment","targetName","allowedCaveats","SnapCaveatType","TransactionOrigin","MaxRequestTime","endowmentGetter","_getterOptions","undefined","validator","createGenericPermissionValidator","type","optional","subjectTypes","SubjectType","Snap","Object","freeze","validateCaveat","caveat","hasProperty","isPlainObject","rpcErrors","invalidParams","message","value","assert","isObject","keys","length","caveats","allowTransactionOrigin","permission"],"mappings":";;;;;;;;;;;IAwDaA,kCAAkC;eAAlCA;;IAkCGC,iCAAiC;eAAjCA;;IAiCAC,0BAA0B;eAA1BA;;IAeHC,sCAAsC;eAAtCA;;;sCAjI+B;2BAClB;4BACK;uBAE8B;yBAEZ;sBAClB;AAE/B,MAAMC,iBAAiBC,oBAAc,CAACC,kBAAkB;AAUxD;;;;;;CAMC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,SAAS;QACxCC,YAAYR;QACZS,gBAAgB;YACdC,0BAAc,CAACC,iBAAiB;YAChCD,0BAAc,CAACE,cAAc;SAC9B;QACDC,iBAAiB,CAACC,iBAA2CC;QAC7DC,WAAWC,IAAAA,yCAAgC,EAAC;YAC1C;gBAAEC,MAAMR,0BAAc,CAACC,iBAAiB;gBAAEQ,UAAU;YAAK;YACzD;gBAAED,MAAMR,0BAAc,CAACE,cAAc;gBAAEO,UAAU;YAAK;SACvD;QACDC,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEO,MAAM1B,qCAAqC2B,OAAOC,MAAM,CAAC;IAC9DhB,YAAYR;IACZG;AACF;AAEA;;;;;CAKC,GACD,SAASsB,eAAeC,MAA2B;IACjD,IAAI,CAACC,IAAAA,kBAAW,EAACD,QAAQ,YAAY,CAACE,IAAAA,oBAAa,EAACF,SAAS;QAC3D,MAAMG,oBAAS,CAACC,aAAa,CAAC;YAC5BC,SAAS;QACX;IACF;IAEA,MAAM,EAAEC,KAAK,EAAE,GAAGN;IAElBO,IAAAA,aAAM,EACJ,OAAOD,UAAU,WACjB;AAEJ;AAUO,SAASnC,kCACdmC,KAAW;IAEX,IACE,CAACA,SACD,CAACE,IAAAA,eAAQ,EAACF,UACTE,IAAAA,eAAQ,EAACF,UAAUT,OAAOY,IAAI,CAACH,OAAOI,MAAM,KAAK,GAClD;QACA,OAAO;YAAEC,SAAS;QAAK;IACzB;IACA,OAAO;QACLA,SAAS;YACP;gBACEnB,MAAMR,0BAAc,CAACC,iBAAiB;gBACtCqB,OACEL,IAAAA,kBAAW,EAACK,OAAO,6BAClBA,MAAMM,sBAAsB;YACjC;SACD;IACH;AACF;AAaO,SAASxC,2BACdyC,UAAiC;IAEjC,IAAI,CAACA,YAAYF,SAAS;QACxB,OAAO;IACT;IAEAJ,IAAAA,aAAM,EAACM,WAAWF,OAAO,CAACD,MAAM,KAAK;IACrCH,IAAAA,aAAM,EAACM,WAAWF,OAAO,CAAC,EAAE,CAACnB,IAAI,KAAKR,0BAAc,CAACC,iBAAiB;IAEtE,MAAMe,SAASa,WAAWF,OAAO,CAAC,EAAE;IAEpC,OAAOX,OAAOM,KAAK,IAAI;AACzB;AAEO,MAAMjC,yCAGT;IACF,CAACW,0BAAc,CAACC,iBAAiB,CAAC,EAAEY,OAAOC,MAAM,CAAC;QAChDN,MAAMR,0BAAc,CAACC,iBAAiB;QACtCK,WAAW,CAACU,SAAgCD,eAAeC;IAC7D;AACF"}

package/dist/cjs/endowments/web-assembly.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "webAssemblyEndowmentBuilder", {
+    enumerable: true,
+    get: function() {
+        return webAssemblyEndowmentBuilder;
+    }
+});
+const _permissioncontroller = require("@metamask/permission-controller");
+const _enum = require("./enum");
+const permissionName = _enum.SnapEndowments.WebAssemblyAccess;
+/**
+ * `endowment:webassembly` returns the name of global browser API(s) that
+ * enable access to the WebAssembly API.
+ * This is intended to populate the endowments of the SES Compartment
+ * in which a Snap executes.
+ *
+ * @param _builderOptions - Optional specification builder options.
+ * @returns The specification for the WebAssembly endowment.
+ */ const specificationBuilder = (_builderOptions)=>{
+    return {
+        permissionType: _permissioncontroller.PermissionType.Endowment,
+        targetName: permissionName,
+        allowedCaveats: null,
+        endowmentGetter: (_getterOptions)=>{
+            return [
+                'WebAssembly'
+            ];
+        },
+        subjectTypes: [
+            _permissioncontroller.SubjectType.Snap
+        ]
+    };
+};
+const webAssemblyEndowmentBuilder = Object.freeze({
+    targetName: permissionName,
+    specificationBuilder
+});
+
+//# sourceMappingURL=web-assembly.js.map

package/dist/cjs/endowments/web-assembly.js.map

@@ -0,0 +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"}

package/dist/cjs/index.js

@@ -23,9 +23,11 @@ _export(exports, {
     }
 });
 const _permitted = require("./permitted");
-_export_star(require("./restricted"), exports);
 const _snapsutils = require("@metamask/snaps-utils");
 const _utils = require("./utils");
+_export_star(require("./endowments"), exports);
+_export_star(require("./permissions"), exports);
+_export_star(require("./restricted"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export type { PermittedRpcMethodHooks } from './permitted';\nexport {\n  handlers as permittedMethods,\n  createSnapsMethodMiddleware,\n} from './permitted';\nexport * from './restricted';\nexport { SnapCaveatType } from '@metamask/snaps-utils';\nexport { selectHooks } from './utils';\n"],"names":["permittedMethods","handlers","createSnapsMethodMiddleware","SnapCaveatType","selectHooks"],"mappings":";;;;;;;;;;;IAEcA,gBAAgB;eAA5BC,mBAAQ;;IACRC,2BAA2B;eAA3BA,sCAA2B;;IAGpBC,cAAc;eAAdA,0BAAc;;IACdC,WAAW;eAAXA,kBAAW;;;2BAHb;qBACO;4BACiB;uBACH"}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export {\n  handlers as permittedMethods,\n  createSnapsMethodMiddleware,\n} from './permitted';\nexport type { PermittedRpcMethodHooks } from './permitted';\nexport { SnapCaveatType } from '@metamask/snaps-utils';\nexport { selectHooks } from './utils';\nexport * from './endowments';\nexport * from './permissions';\nexport * from './restricted';\n"],"names":["permittedMethods","handlers","createSnapsMethodMiddleware","SnapCaveatType","selectHooks"],"mappings":";;;;;;;;;;;IACcA,gBAAgB;eAA5BC,mBAAQ;;IACRC,2BAA2B;eAA3BA,sCAA2B;;IAGpBC,cAAc;eAAdA,0BAAc;;IACdC,WAAW;eAAXA,kBAAW;;;2BAHb;4BAEwB;uBACH;qBACd;qBACA;qBACA"}

package/dist/cjs/permissions.js

@@ -0,0 +1,62 @@
+"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, {
+    processSnapPermissions: function() {
+        return processSnapPermissions;
+    },
+    buildSnapEndowmentSpecifications: function() {
+        return buildSnapEndowmentSpecifications;
+    },
+    buildSnapRestrictedMethodSpecifications: function() {
+        return buildSnapRestrictedMethodSpecifications;
+    }
+});
+const _utils = require("@metamask/utils");
+const _endowments = require("./endowments");
+const _restricted = require("./restricted");
+const _utils1 = require("./utils");
+function processSnapPermissions(initialPermissions) {
+    return Object.fromEntries(Object.entries(initialPermissions).map(([initialPermission, value])=>{
+        if ((0, _utils.hasProperty)(_restricted.caveatMappers, initialPermission)) {
+            return [
+                initialPermission,
+                _restricted.caveatMappers[initialPermission](value)
+            ];
+        } else if ((0, _utils.hasProperty)(_endowments.endowmentCaveatMappers, initialPermission)) {
+            return [
+                initialPermission,
+                _endowments.endowmentCaveatMappers[initialPermission](value)
+            ];
+        }
+        // If we have no mapping, this may be a non-snap permission, return as-is
+        return [
+            initialPermission,
+            value
+        ];
+    }));
+}
+const buildSnapEndowmentSpecifications = (excludedEndowments)=>Object.values(_endowments.endowmentPermissionBuilders).reduce((allSpecifications, { targetName, specificationBuilder })=>{
+        if (!excludedEndowments.includes(targetName)) {
+            allSpecifications[targetName] = specificationBuilder({});
+        }
+        return allSpecifications;
+    }, {});
+const buildSnapRestrictedMethodSpecifications = (excludedPermissions, hooks)=>Object.values(_restricted.restrictedMethodPermissionBuilders).reduce((specifications, { targetName, specificationBuilder, methodHooks })=>{
+        if (!excludedPermissions.includes(targetName)) {
+            specifications[targetName] = specificationBuilder({
+                // @ts-expect-error The selectHooks type is wonky
+                methodHooks: (0, _utils1.selectHooks)(hooks, methodHooks)
+            });
+        }
+        return specifications;
+    }, {});
+
+//# sourceMappingURL=permissions.js.map

package/dist/cjs/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/permissions.ts"],"sourcesContent":["import type {\n  PermissionConstraint,\n  PermissionSpecificationConstraint,\n} from '@metamask/permission-controller';\nimport type { SnapPermissions } from '@metamask/snaps-utils';\nimport { hasProperty } from '@metamask/utils';\n\nimport {\n  endowmentCaveatMappers,\n  endowmentPermissionBuilders,\n} from './endowments';\nimport {\n  caveatMappers,\n  restrictedMethodPermissionBuilders,\n} from './restricted';\nimport { selectHooks } from './utils';\n\n/**\n * Map initial permissions as defined in a Snap manifest to something that can\n * be processed by the PermissionsController. Each caveat mapping function\n * should return a valid permission caveat value.\n *\n * This function does not validate the caveat values, since that is done by\n * the PermissionsController itself, upon requesting the permissions.\n *\n * @param initialPermissions - The initial permissions to process.\n * @returns The processed permissions.\n */\nexport function processSnapPermissions(\n  initialPermissions: SnapPermissions,\n): Record<string, Pick<PermissionConstraint, 'caveats'>> {\n  return Object.fromEntries(\n    Object.entries(initialPermissions).map(([initialPermission, value]) => {\n      if (hasProperty(caveatMappers, initialPermission)) {\n        return [initialPermission, caveatMappers[initialPermission](value)];\n      } else if (hasProperty(endowmentCaveatMappers, initialPermission)) {\n        return [\n          initialPermission,\n          endowmentCaveatMappers[initialPermission](value),\n        ];\n      }\n\n      // If we have no mapping, this may be a non-snap permission, return as-is\n      return [\n        initialPermission,\n        value as Pick<PermissionConstraint, 'caveats'>,\n      ];\n    }),\n  );\n}\n\nexport const buildSnapEndowmentSpecifications = (\n  excludedEndowments: string[],\n) =>\n  Object.values(endowmentPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((allSpecifications, { targetName, specificationBuilder }) => {\n    if (!excludedEndowments.includes(targetName)) {\n      allSpecifications[targetName] = specificationBuilder({});\n    }\n    return allSpecifications;\n  }, {});\n\nexport const buildSnapRestrictedMethodSpecifications = (\n  excludedPermissions: string[],\n  hooks: Record<string, unknown>,\n) =>\n  Object.values(restrictedMethodPermissionBuilders).reduce<\n    Record<string, PermissionSpecificationConstraint>\n  >((specifications, { targetName, specificationBuilder, methodHooks }) => {\n    if (!excludedPermissions.includes(targetName)) {\n      specifications[targetName] = specificationBuilder({\n        // @ts-expect-error The selectHooks type is wonky\n        methodHooks: selectHooks<typeof hooks, keyof typeof methodHooks>(\n          hooks,\n          methodHooks,\n        ) as Pick<typeof hooks, keyof typeof methodHooks>,\n      });\n    }\n    return specifications;\n  }, {});\n"],"names":["processSnapPermissions","buildSnapEndowmentSpecifications","buildSnapRestrictedMethodSpecifications","initialPermissions","Object","fromEntries","entries","map","initialPermission","value","hasProperty","caveatMappers","endowmentCaveatMappers","excludedEndowments","values","endowmentPermissionBuilders","reduce","allSpecifications","targetName","specificationBuilder","includes","excludedPermissions","hooks","restrictedMethodPermissionBuilders","specifications","methodHooks","selectHooks"],"mappings":";;;;;;;;;;;IA4BgBA,sBAAsB;eAAtBA;;IAuBHC,gCAAgC;eAAhCA;;IAYAC,uCAAuC;eAAvCA;;;uBA1De;4BAKrB;4BAIA;wBACqB;AAarB,SAASF,uBACdG,kBAAmC;IAEnC,OAAOC,OAAOC,WAAW,CACvBD,OAAOE,OAAO,CAACH,oBAAoBI,GAAG,CAAC,CAAC,CAACC,mBAAmBC,MAAM;QAChE,IAAIC,IAAAA,kBAAW,EAACC,yBAAa,EAAEH,oBAAoB;YACjD,OAAO;gBAACA;gBAAmBG,yBAAa,CAACH,kBAAkB,CAACC;aAAO;QACrE,OAAO,IAAIC,IAAAA,kBAAW,EAACE,kCAAsB,EAAEJ,oBAAoB;YACjE,OAAO;gBACLA;gBACAI,kCAAsB,CAACJ,kBAAkB,CAACC;aAC3C;QACH;QAEA,yEAAyE;QACzE,OAAO;YACLD;YACAC;SACD;IACH;AAEJ;AAEO,MAAMR,mCAAmC,CAC9CY,qBAEAT,OAAOU,MAAM,CAACC,uCAA2B,EAAEC,MAAM,CAE/C,CAACC,mBAAmB,EAAEC,UAAU,EAAEC,oBAAoB,EAAE;QACxD,IAAI,CAACN,mBAAmBO,QAAQ,CAACF,aAAa;YAC5CD,iBAAiB,CAACC,WAAW,GAAGC,qBAAqB,CAAC;QACxD;QACA,OAAOF;IACT,GAAG,CAAC;AAEC,MAAMf,0CAA0C,CACrDmB,qBACAC,QAEAlB,OAAOU,MAAM,CAACS,8CAAkC,EAAEP,MAAM,CAEtD,CAACQ,gBAAgB,EAAEN,UAAU,EAAEC,oBAAoB,EAAEM,WAAW,EAAE;QAClE,IAAI,CAACJ,oBAAoBD,QAAQ,CAACF,aAAa;YAC7CM,cAAc,CAACN,WAAW,GAAGC,qBAAqB;gBAChD,iDAAiD;gBACjDM,aAAaC,IAAAA,mBAAW,EACtBJ,OACAG;YAEJ;QACF;QACA,OAAOD;IACT,GAAG,CAAC"}

package/dist/cjs/permitted/createInterface.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createInterfaceHandler", {
+    enumerable: true,
+    get: function() {
+        return createInterfaceHandler;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _snapssdk = require("@metamask/snaps-sdk");
+const _superstruct = require("superstruct");
+const hookNames = {
+    createInterface: true
+};
+const createInterfaceHandler = {
+    methodNames: [
+        'snap_createInterface'
+    ],
+    implementation: getCreateInterfaceImplementation,
+    hookNames
+};
+const CreateInterfaceParametersStruct = (0, _superstruct.object)({
+    ui: _snapssdk.ComponentStruct
+});
+/**
+ * The `snap_createInterface` method implementation.
+ *
+ * @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.createInterface - The function to create the interface.
+ * @returns Nothing.
+ */ async function getCreateInterfaceImplementation(req, res, _next, end, { createInterface }) {
+    const { params } = req;
+    try {
+        const validatedParams = getValidatedParams(params);
+        const { ui } = validatedParams;
+        res.result = await createInterface(ui);
+    } catch (error) {
+        return end(error);
+    }
+    return end();
+}
+/**
+ * Validate the createInterface method `params` and returns them cast to the correct
+ * type. Throws if validation fails.
+ *
+ * @param params - The unvalidated params object from the method request.
+ * @returns The validated createInterface method parameter object.
+ */ function getValidatedParams(params) {
+    try {
+        return (0, _superstruct.create)(params, CreateInterfaceParametersStruct);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw _rpcerrors.rpcErrors.invalidParams({
+                message: `Invalid params: ${error.message}.`
+            });
+        }
+        /* istanbul ignore next */ throw _rpcerrors.rpcErrors.internal();
+    }
+}
+
+//# sourceMappingURL=createInterface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/createInterface.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  Component,\n  CreateInterfaceParams,\n  CreateInterfaceResult,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { ComponentStruct } from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<CreateInterfaceMethodHooks> = {\n  createInterface: true,\n};\n\nexport type CreateInterfaceMethodHooks = {\n  /**\n   * @param ui - The UI components.\n   * @returns The unique identifier of the interface.\n   */\n  createInterface: (ui: Component) => Promise<string>;\n};\n\nexport const createInterfaceHandler: PermittedHandlerExport<\n  CreateInterfaceMethodHooks,\n  CreateInterfaceParameters,\n  CreateInterfaceResult\n> = {\n  methodNames: ['snap_createInterface'],\n  implementation: getCreateInterfaceImplementation,\n  hookNames,\n};\n\nconst CreateInterfaceParametersStruct = object({\n  ui: ComponentStruct,\n});\n\nexport type CreateInterfaceParameters = InferMatching<\n  typeof CreateInterfaceParametersStruct,\n  CreateInterfaceParams\n>;\n\n/**\n * The `snap_createInterface` method implementation.\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.createInterface - The function to create the interface.\n * @returns Nothing.\n */\nasync function getCreateInterfaceImplementation(\n  req: JsonRpcRequest<CreateInterfaceParameters>,\n  res: PendingJsonRpcResponse<CreateInterfaceResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { createInterface }: CreateInterfaceMethodHooks,\n): Promise<void> {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { ui } = validatedParams;\n\n    res.result = await createInterface(ui);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the createInterface method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated createInterface method parameter object.\n */\nfunction getValidatedParams(params: unknown): CreateInterfaceParameters {\n  try {\n    return create(params, CreateInterfaceParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"names":["createInterfaceHandler","hookNames","createInterface","methodNames","implementation","getCreateInterfaceImplementation","CreateInterfaceParametersStruct","object","ui","ComponentStruct","req","res","_next","end","params","validatedParams","getValidatedParams","result","error","create","StructError","rpcErrors","invalidParams","message","internal"],"mappings":";;;;+BA4BaA;;;eAAAA;;;2BA1Ba;0BAOM;6BAGY;AAI5C,MAAMC,YAA2D;IAC/DC,iBAAiB;AACnB;AAUO,MAAMF,yBAIT;IACFG,aAAa;QAAC;KAAuB;IACrCC,gBAAgBC;IAChBJ;AACF;AAEA,MAAMK,kCAAkCC,IAAAA,mBAAM,EAAC;IAC7CC,IAAIC,yBAAe;AACrB;AAOA;;;;;;;;;;;CAWC,GACD,eAAeJ,iCACbK,GAA8C,EAC9CC,GAAkD,EAClDC,KAAc,EACdC,GAA6B,EAC7B,EAAEX,eAAe,EAA8B;IAE/C,MAAM,EAAEY,MAAM,EAAE,GAAGJ;IAEnB,IAAI;QACF,MAAMK,kBAAkBC,mBAAmBF;QAE3C,MAAM,EAAEN,EAAE,EAAE,GAAGO;QAEfJ,IAAIM,MAAM,GAAG,MAAMf,gBAAgBM;IACrC,EAAE,OAAOU,OAAO;QACd,OAAOL,IAAIK;IACb;IAEA,OAAOL;AACT;AAEA;;;;;;CAMC,GACD,SAASG,mBAAmBF,MAAe;IACzC,IAAI;QACF,OAAOK,IAAAA,mBAAM,EAACL,QAAQR;IACxB,EAAE,OAAOY,OAAO;QACd,IAAIA,iBAAiBE,wBAAW,EAAE;YAChC,MAAMC,oBAAS,CAACC,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gBAAgB,EAAEL,MAAMK,OAAO,CAAC,CAAC,CAAC;YAC9C;QACF;QACA,wBAAwB,GACxB,MAAMF,oBAAS,CAACG,QAAQ;IAC1B;AACF"}

package/dist/cjs/permitted/getFile.js

@@ -47,7 +47,7 @@ const getFileHandler = {
  * function.
  * @param end - The `json-rpc-engine` "end" callback.
  * @param hooks - The RPC method hooks.
- * @param hooks.getSnapFile - The funnction to load a static snap file.
+ * @param hooks.getSnapFile - The function to load a static snap file.
  * @returns Nothing.
  */ async function implementation(req, res, _next, end, { getSnapFile }) {
     const { params } = req;

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/permitted/getFile.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { GetFileParams, GetFileResult } from '@metamask/snaps-sdk';\nimport { AuxiliaryFileEncoding, enumValue } from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { object, optional, string, union } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nexport const GetFileArgsStruct = object({\n  path: string(),\n  encoding: optional(\n    union([\n      enumValue(AuxiliaryFileEncoding.Base64),\n      enumValue(AuxiliaryFileEncoding.Hex),\n      enumValue(AuxiliaryFileEncoding.Utf8),\n    ]),\n  ),\n});\n\nexport type InferredGetFileParams = InferMatching<\n  typeof GetFileArgsStruct,\n  GetFileParams\n>;\n\nconst hookNames: MethodHooksObject<GetFileHooks> = {\n  getSnapFile: true,\n};\n\nexport const getFileHandler: PermittedHandlerExport<\n  GetFileHooks,\n  InferredGetFileParams,\n  string\n> = {\n  methodNames: ['snap_getFile'],\n  implementation,\n  hookNames,\n};\n\nexport type GetFileHooks = {\n  getSnapFile: (\n    path: InferredGetFileParams['path'],\n    encoding: InferredGetFileParams['encoding'],\n  ) => Promise<string>;\n};\n\n/**\n * The `snap_getFile` method implementation.\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.getSnapFile - The funnction to load a static snap file.\n * @returns Nothing.\n */\nasync function implementation(\n  req: JsonRpcRequest<InferredGetFileParams>,\n  res: PendingJsonRpcResponse<GetFileResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnapFile }: GetFileHooks,\n): Promise<void> {\n  const { params } = req;\n\n  assertStruct(\n    params,\n    GetFileArgsStruct,\n    'Invalid \"snap_getFile\" parameters',\n    rpcErrors.invalidParams,\n  );\n\n  try {\n    res.result = await getSnapFile(\n      params.path,\n      params.encoding ?? AuxiliaryFileEncoding.Base64,\n    );\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n"],"names":["GetFileArgsStruct","getFileHandler","object","path","string","encoding","optional","union","enumValue","AuxiliaryFileEncoding","Base64","Hex","Utf8","hookNames","getSnapFile","methodNames","implementation","req","res","_next","end","params","assertStruct","rpcErrors","invalidParams","result","error"],"mappings":";;;;;;;;;;;IAYaA,iBAAiB;eAAjBA;;IAoBAC,cAAc;eAAdA;;;2BA9Ba;0BAEuB;uBAGpB;6BACmB;AAIzC,MAAMD,oBAAoBE,IAAAA,mBAAM,EAAC;IACtCC,MAAMC,IAAAA,mBAAM;IACZC,UAAUC,IAAAA,qBAAQ,EAChBC,IAAAA,kBAAK,EAAC;QACJC,IAAAA,mBAAS,EAACC,+BAAqB,CAACC,MAAM;QACtCF,IAAAA,mBAAS,EAACC,+BAAqB,CAACE,GAAG;QACnCH,IAAAA,mBAAS,EAACC,+BAAqB,CAACG,IAAI;KACrC;AAEL;AAOA,MAAMC,YAA6C;IACjDC,aAAa;AACf;AAEO,MAAMb,iBAIT;IACFc,aAAa;QAAC;KAAe;IAC7BC;IACAH;AACF;AASA;;;;;;;;;;;CAWC,GACD,eAAeG,eACbC,GAA0C,EAC1CC,GAA0C,EAC1CC,KAAc,EACdC,GAA6B,EAC7B,EAAEN,WAAW,EAAgB;IAE7B,MAAM,EAAEO,MAAM,EAAE,GAAGJ;IAEnBK,IAAAA,mBAAY,EACVD,QACArB,mBACA,qCACAuB,oBAAS,CAACC,aAAa;IAGzB,IAAI;QACFN,IAAIO,MAAM,GAAG,MAAMX,YACjBO,OAAOlB,IAAI,EACXkB,OAAOhB,QAAQ,IAAII,+BAAqB,CAACC,MAAM;IAEnD,EAAE,OAAOgB,OAAO;QACd,OAAON,IAAIM;IACb;IAEA,OAAON;AACT"}
+{"version":3,"sources":["../../../src/permitted/getFile.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type { GetFileParams, GetFileResult } from '@metamask/snaps-sdk';\nimport { AuxiliaryFileEncoding, enumValue } from '@metamask/snaps-sdk';\nimport type { InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse, JsonRpcRequest } from '@metamask/utils';\nimport { assertStruct } from '@metamask/utils';\nimport { object, optional, string, union } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nexport const GetFileArgsStruct = object({\n  path: string(),\n  encoding: optional(\n    union([\n      enumValue(AuxiliaryFileEncoding.Base64),\n      enumValue(AuxiliaryFileEncoding.Hex),\n      enumValue(AuxiliaryFileEncoding.Utf8),\n    ]),\n  ),\n});\n\nexport type InferredGetFileParams = InferMatching<\n  typeof GetFileArgsStruct,\n  GetFileParams\n>;\n\nconst hookNames: MethodHooksObject<GetFileHooks> = {\n  getSnapFile: true,\n};\n\nexport const getFileHandler: PermittedHandlerExport<\n  GetFileHooks,\n  InferredGetFileParams,\n  string\n> = {\n  methodNames: ['snap_getFile'],\n  implementation,\n  hookNames,\n};\n\nexport type GetFileHooks = {\n  getSnapFile: (\n    path: InferredGetFileParams['path'],\n    encoding: InferredGetFileParams['encoding'],\n  ) => Promise<string>;\n};\n\n/**\n * The `snap_getFile` method implementation.\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.getSnapFile - The function to load a static snap file.\n * @returns Nothing.\n */\nasync function implementation(\n  req: JsonRpcRequest<InferredGetFileParams>,\n  res: PendingJsonRpcResponse<GetFileResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getSnapFile }: GetFileHooks,\n): Promise<void> {\n  const { params } = req;\n\n  assertStruct(\n    params,\n    GetFileArgsStruct,\n    'Invalid \"snap_getFile\" parameters',\n    rpcErrors.invalidParams,\n  );\n\n  try {\n    res.result = await getSnapFile(\n      params.path,\n      params.encoding ?? AuxiliaryFileEncoding.Base64,\n    );\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n"],"names":["GetFileArgsStruct","getFileHandler","object","path","string","encoding","optional","union","enumValue","AuxiliaryFileEncoding","Base64","Hex","Utf8","hookNames","getSnapFile","methodNames","implementation","req","res","_next","end","params","assertStruct","rpcErrors","invalidParams","result","error"],"mappings":";;;;;;;;;;;IAYaA,iBAAiB;eAAjBA;;IAoBAC,cAAc;eAAdA;;;2BA9Ba;0BAEuB;uBAGpB;6BACmB;AAIzC,MAAMD,oBAAoBE,IAAAA,mBAAM,EAAC;IACtCC,MAAMC,IAAAA,mBAAM;IACZC,UAAUC,IAAAA,qBAAQ,EAChBC,IAAAA,kBAAK,EAAC;QACJC,IAAAA,mBAAS,EAACC,+BAAqB,CAACC,MAAM;QACtCF,IAAAA,mBAAS,EAACC,+BAAqB,CAACE,GAAG;QACnCH,IAAAA,mBAAS,EAACC,+BAAqB,CAACG,IAAI;KACrC;AAEL;AAOA,MAAMC,YAA6C;IACjDC,aAAa;AACf;AAEO,MAAMb,iBAIT;IACFc,aAAa;QAAC;KAAe;IAC7BC;IACAH;AACF;AASA;;;;;;;;;;;CAWC,GACD,eAAeG,eACbC,GAA0C,EAC1CC,GAA0C,EAC1CC,KAAc,EACdC,GAA6B,EAC7B,EAAEN,WAAW,EAAgB;IAE7B,MAAM,EAAEO,MAAM,EAAE,GAAGJ;IAEnBK,IAAAA,mBAAY,EACVD,QACArB,mBACA,qCACAuB,oBAAS,CAACC,aAAa;IAGzB,IAAI;QACFN,IAAIO,MAAM,GAAG,MAAMX,YACjBO,OAAOlB,IAAI,EACXkB,OAAOhB,QAAQ,IAAII,+BAAqB,CAACC,MAAM;IAEnD,EAAE,OAAOgB,OAAO;QACd,OAAON,IAAIM;IACb;IAEA,OAAON;AACT"}

package/dist/cjs/permitted/getInterfaceState.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getInterfaceStateHandler", {
+    enumerable: true,
+    get: function() {
+        return getInterfaceStateHandler;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _superstruct = require("superstruct");
+const hookNames = {
+    getInterfaceState: true
+};
+const getInterfaceStateHandler = {
+    methodNames: [
+        'snap_getInterfaceState'
+    ],
+    implementation: getGetInterfaceStateImplementation,
+    hookNames
+};
+const GetInterfaceStateParametersStruct = (0, _superstruct.object)({
+    id: (0, _superstruct.string)()
+});
+/**
+ * The `snap_getInterfaceState` method implementation.
+ *
+ * @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.getInterfaceState - The function to get the interface state.
+ * @returns Noting.
+ */ function getGetInterfaceStateImplementation(req, res, _next, end, { getInterfaceState }) {
+    const { params } = req;
+    try {
+        const validatedParams = getValidatedParams(params);
+        const { id } = validatedParams;
+        res.result = getInterfaceState(id);
+    } catch (error) {
+        return end(error);
+    }
+    return end();
+}
+/**
+ * Validate the getInterfaceState method `params` and returns them cast to the correct
+ * type. Throws if validation fails.
+ *
+ * @param params - The unvalidated params object from the method request.
+ * @returns The validated getInterfaceState method parameter object.
+ */ function getValidatedParams(params) {
+    try {
+        return (0, _superstruct.create)(params, GetInterfaceStateParametersStruct);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw _rpcerrors.rpcErrors.invalidParams({
+                message: `Invalid params: ${error.message}.`
+            });
+        }
+        /* istanbul ignore next */ throw _rpcerrors.rpcErrors.internal();
+    }
+}
+
+//# sourceMappingURL=getInterfaceState.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/getInterfaceState.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  GetInterfaceStateParams,\n  GetInterfaceStateResult,\n  InterfaceState,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<GetInterfaceStateMethodHooks> = {\n  getInterfaceState: true,\n};\n\nexport type GetInterfaceStateMethodHooks = {\n  /**\n   * @param id - The interface ID.\n   * @returns The interface state.\n   */\n  getInterfaceState: (id: string) => InterfaceState;\n};\n\nexport const getInterfaceStateHandler: PermittedHandlerExport<\n  GetInterfaceStateMethodHooks,\n  GetInterfaceStateParameters,\n  GetInterfaceStateResult\n> = {\n  methodNames: ['snap_getInterfaceState'],\n  implementation: getGetInterfaceStateImplementation,\n  hookNames,\n};\n\nconst GetInterfaceStateParametersStruct = object({\n  id: string(),\n});\n\nexport type GetInterfaceStateParameters = InferMatching<\n  typeof GetInterfaceStateParametersStruct,\n  GetInterfaceStateParams\n>;\n\n/**\n * The `snap_getInterfaceState` method implementation.\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.getInterfaceState - The function to get the interface state.\n * @returns Noting.\n */\nfunction getGetInterfaceStateImplementation(\n  req: JsonRpcRequest<GetInterfaceStateParameters>,\n  res: PendingJsonRpcResponse<GetInterfaceStateResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getInterfaceState }: GetInterfaceStateMethodHooks,\n): void {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { id } = validatedParams;\n\n    res.result = getInterfaceState(id);\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the getInterfaceState method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated getInterfaceState method parameter object.\n */\nfunction getValidatedParams(params: unknown): GetInterfaceStateParameters {\n  try {\n    return create(params, GetInterfaceStateParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"names":["getInterfaceStateHandler","hookNames","getInterfaceState","methodNames","implementation","getGetInterfaceStateImplementation","GetInterfaceStateParametersStruct","object","id","string","req","res","_next","end","params","validatedParams","getValidatedParams","result","error","create","StructError","rpcErrors","invalidParams","message","internal"],"mappings":";;;;+BA2BaA;;;eAAAA;;;2BAzBa;6BAS0B;AAIpD,MAAMC,YAA6D;IACjEC,mBAAmB;AACrB;AAUO,MAAMF,2BAIT;IACFG,aAAa;QAAC;KAAyB;IACvCC,gBAAgBC;IAChBJ;AACF;AAEA,MAAMK,oCAAoCC,IAAAA,mBAAM,EAAC;IAC/CC,IAAIC,IAAAA,mBAAM;AACZ;AAOA;;;;;;;;;;;CAWC,GACD,SAASJ,mCACPK,GAAgD,EAChDC,GAAoD,EACpDC,KAAc,EACdC,GAA6B,EAC7B,EAAEX,iBAAiB,EAAgC;IAEnD,MAAM,EAAEY,MAAM,EAAE,GAAGJ;IAEnB,IAAI;QACF,MAAMK,kBAAkBC,mBAAmBF;QAE3C,MAAM,EAAEN,EAAE,EAAE,GAAGO;QAEfJ,IAAIM,MAAM,GAAGf,kBAAkBM;IACjC,EAAE,OAAOU,OAAO;QACd,OAAOL,IAAIK;IACb;IAEA,OAAOL;AACT;AAEA;;;;;;CAMC,GACD,SAASG,mBAAmBF,MAAe;IACzC,IAAI;QACF,OAAOK,IAAAA,mBAAM,EAACL,QAAQR;IACxB,EAAE,OAAOY,OAAO;QACd,IAAIA,iBAAiBE,wBAAW,EAAE;YAChC,MAAMC,oBAAS,CAACC,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gBAAgB,EAAEL,MAAMK,OAAO,CAAC,CAAC,CAAC;YAC9C;QACF;QACA,wBAAwB,GACxB,MAAMF,oBAAS,CAACG,QAAQ;IAC1B;AACF"}

package/dist/cjs/permitted/handlers.js

@@ -16,13 +16,16 @@ _export(exports, {
         return handlers;
     }
 });
+const _createInterface = require("./createInterface");
 const _getAllSnaps = require("./getAllSnaps");
 const _getClientStatus = require("./getClientStatus");
 const _getFile = require("./getFile");
+const _getInterfaceState = require("./getInterfaceState");
 const _getSnaps = require("./getSnaps");
 const _invokeKeyring = require("./invokeKeyring");
 const _invokeSnapSugar = require("./invokeSnapSugar");
 const _requestSnaps = require("./requestSnaps");
+const _updateInterface = require("./updateInterface");
 const methodHandlers = {
     wallet_getAllSnaps: _getAllSnaps.getAllSnapsHandler,
     wallet_getSnaps: _getSnaps.getSnapsHandler,
@@ -30,7 +33,10 @@ const methodHandlers = {
     wallet_invokeSnap: _invokeSnapSugar.invokeSnapSugarHandler,
     wallet_invokeKeyring: _invokeKeyring.invokeKeyringHandler,
     snap_getClientStatus: _getClientStatus.getClientStatusHandler,
-    snap_getFile: _getFile.getFileHandler
+    snap_getFile: _getFile.getFileHandler,
+    snap_createInterface: _createInterface.createInterfaceHandler,
+    snap_updateInterface: _updateInterface.updateInterfaceHandler,
+    snap_getInterfaceState: _getInterfaceState.getInterfaceStateHandler
 };
 const handlers = Object.values(methodHandlers);
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/permitted/handlers.ts"],"sourcesContent":["import { getAllSnapsHandler } from './getAllSnaps';\nimport { getClientStatusHandler } from './getClientStatus';\nimport { getFileHandler } from './getFile';\nimport { getSnapsHandler } from './getSnaps';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { requestSnapsHandler } from './requestSnaps';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const methodHandlers = {\n  wallet_getAllSnaps: getAllSnapsHandler,\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_getClientStatus: getClientStatusHandler,\n  snap_getFile: getFileHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\nexport const handlers = Object.values(methodHandlers);\n"],"names":["methodHandlers","handlers","wallet_getAllSnaps","getAllSnapsHandler","wallet_getSnaps","getSnapsHandler","wallet_requestSnaps","requestSnapsHandler","wallet_invokeSnap","invokeSnapSugarHandler","wallet_invokeKeyring","invokeKeyringHandler","snap_getClientStatus","getClientStatusHandler","snap_getFile","getFileHandler","Object","values"],"mappings":";;;;;;;;;;;IASaA,cAAc;eAAdA;;IAWAC,QAAQ;eAARA;;;6BApBsB;iCACI;yBACR;0BACC;+BACK;iCACE;8BACH;AAG7B,MAAMD,iBAAiB;IAC5BE,oBAAoBC,+BAAkB;IACtCC,iBAAiBC,yBAAe;IAChCC,qBAAqBC,iCAAmB;IACxCC,mBAAmBC,uCAAsB;IACzCC,sBAAsBC,mCAAoB;IAC1CC,sBAAsBC,uCAAsB;IAC5CC,cAAcC,uBAAc;AAC9B;AAGO,MAAMd,WAAWe,OAAOC,MAAM,CAACjB"}
+{"version":3,"sources":["../../../src/permitted/handlers.ts"],"sourcesContent":["import { createInterfaceHandler } from './createInterface';\nimport { getAllSnapsHandler } from './getAllSnaps';\nimport { getClientStatusHandler } from './getClientStatus';\nimport { getFileHandler } from './getFile';\nimport { getInterfaceStateHandler } from './getInterfaceState';\nimport { getSnapsHandler } from './getSnaps';\nimport { invokeKeyringHandler } from './invokeKeyring';\nimport { invokeSnapSugarHandler } from './invokeSnapSugar';\nimport { requestSnapsHandler } from './requestSnaps';\nimport { updateInterfaceHandler } from './updateInterface';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const methodHandlers = {\n  wallet_getAllSnaps: getAllSnapsHandler,\n  wallet_getSnaps: getSnapsHandler,\n  wallet_requestSnaps: requestSnapsHandler,\n  wallet_invokeSnap: invokeSnapSugarHandler,\n  wallet_invokeKeyring: invokeKeyringHandler,\n  snap_getClientStatus: getClientStatusHandler,\n  snap_getFile: getFileHandler,\n  snap_createInterface: createInterfaceHandler,\n  snap_updateInterface: updateInterfaceHandler,\n  snap_getInterfaceState: getInterfaceStateHandler,\n};\n/* eslint-enable @typescript-eslint/naming-convention */\n\nexport const handlers = Object.values(methodHandlers);\n"],"names":["methodHandlers","handlers","wallet_getAllSnaps","getAllSnapsHandler","wallet_getSnaps","getSnapsHandler","wallet_requestSnaps","requestSnapsHandler","wallet_invokeSnap","invokeSnapSugarHandler","wallet_invokeKeyring","invokeKeyringHandler","snap_getClientStatus","getClientStatusHandler","snap_getFile","getFileHandler","snap_createInterface","createInterfaceHandler","snap_updateInterface","updateInterfaceHandler","snap_getInterfaceState","getInterfaceStateHandler","Object","values"],"mappings":";;;;;;;;;;;IAYaA,cAAc;eAAdA;;IAcAC,QAAQ;eAARA;;;iCA1B0B;6BACJ;iCACI;yBACR;mCACU;0BACT;+BACK;iCACE;8BACH;iCACG;AAGhC,MAAMD,iBAAiB;IAC5BE,oBAAoBC,+BAAkB;IACtCC,iBAAiBC,yBAAe;IAChCC,qBAAqBC,iCAAmB;IACxCC,mBAAmBC,uCAAsB;IACzCC,sBAAsBC,mCAAoB;IAC1CC,sBAAsBC,uCAAsB;IAC5CC,cAAcC,uBAAc;IAC5BC,sBAAsBC,uCAAsB;IAC5CC,sBAAsBC,uCAAsB;IAC5CC,wBAAwBC,2CAAwB;AAClD;AAGO,MAAMpB,WAAWqB,OAAOC,MAAM,CAACvB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/permitted/index.ts"],"sourcesContent":["import type { GetAllSnapsHooks } from './getAllSnaps';\nimport type { GetClientStatusHooks } from './getClientStatus';\nimport type { GetSnapsHooks } from './getSnaps';\nimport type { RequestSnapsHooks } from './requestSnaps';\n\nexport type PermittedRpcMethodHooks = GetAllSnapsHooks &\n  GetClientStatusHooks &\n  GetSnapsHooks &\n  RequestSnapsHooks;\n\nexport * from './handlers';\nexport * from './middleware';\n"],"names":[],"mappings":";;;;qBAUc;qBACA"}
+{"version":3,"sources":["../../../src/permitted/index.ts"],"sourcesContent":["import type { CreateInterfaceMethodHooks } from './createInterface';\nimport type { GetAllSnapsHooks } from './getAllSnaps';\nimport type { GetClientStatusHooks } from './getClientStatus';\nimport type { GetInterfaceStateMethodHooks } from './getInterfaceState';\nimport type { GetSnapsHooks } from './getSnaps';\nimport type { RequestSnapsHooks } from './requestSnaps';\nimport type { UpdateInterfaceMethodHooks } from './updateInterface';\n\nexport type PermittedRpcMethodHooks = GetAllSnapsHooks &\n  GetClientStatusHooks &\n  GetSnapsHooks &\n  RequestSnapsHooks &\n  CreateInterfaceMethodHooks &\n  UpdateInterfaceMethodHooks &\n  GetInterfaceStateMethodHooks;\n\nexport * from './handlers';\nexport * from './middleware';\n"],"names":[],"mappings":";;;;qBAgBc;qBACA"}

package/dist/cjs/permitted/updateInterface.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "updateInterfaceHandler", {
+    enumerable: true,
+    get: function() {
+        return updateInterfaceHandler;
+    }
+});
+const _rpcerrors = require("@metamask/rpc-errors");
+const _snapssdk = require("@metamask/snaps-sdk");
+const _superstruct = require("superstruct");
+const hookNames = {
+    updateInterface: true
+};
+const updateInterfaceHandler = {
+    methodNames: [
+        'snap_updateInterface'
+    ],
+    implementation: getUpdateInterfaceImplementation,
+    hookNames
+};
+const UpdateInterfaceParametersStruct = (0, _superstruct.object)({
+    id: (0, _superstruct.string)(),
+    ui: _snapssdk.ComponentStruct
+});
+/**
+ * The `snap_updateInterface` method implementation.
+ *
+ * @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.updateInterface - The function to update the interface.
+ * @returns Nothing.
+ */ async function getUpdateInterfaceImplementation(req, res, _next, end, { updateInterface }) {
+    const { params } = req;
+    try {
+        const validatedParams = getValidatedParams(params);
+        const { id, ui } = validatedParams;
+        await updateInterface(id, ui);
+        res.result = null;
+    } catch (error) {
+        return end(error);
+    }
+    return end();
+}
+/**
+ * Validate the updateInterface method `params` and returns them cast to the correct
+ * type. Throws if validation fails.
+ *
+ * @param params - The unvalidated params object from the method request.
+ * @returns The validated updateInterface method parameter object.
+ */ function getValidatedParams(params) {
+    try {
+        return (0, _superstruct.create)(params, UpdateInterfaceParametersStruct);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw _rpcerrors.rpcErrors.invalidParams({
+                message: `Invalid params: ${error.message}.`
+            });
+        }
+        /* istanbul ignore next */ throw _rpcerrors.rpcErrors.internal();
+    }
+}
+
+//# sourceMappingURL=updateInterface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/permitted/updateInterface.ts"],"sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PermittedHandlerExport } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport type {\n  Component,\n  UpdateInterfaceParams,\n  UpdateInterfaceResult,\n  JsonRpcRequest,\n} from '@metamask/snaps-sdk';\nimport { ComponentStruct } from '@metamask/snaps-sdk';\nimport { type InferMatching } from '@metamask/snaps-utils';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\nimport { StructError, create, object, string } from 'superstruct';\n\nimport type { MethodHooksObject } from '../utils';\n\nconst hookNames: MethodHooksObject<UpdateInterfaceMethodHooks> = {\n  updateInterface: true,\n};\n\nexport type UpdateInterfaceMethodHooks = {\n  /**\n   * @param id - The interface ID.\n   * @param ui - The UI components.\n   */\n  updateInterface: (id: string, ui: Component) => Promise<void>;\n};\n\nexport const updateInterfaceHandler: PermittedHandlerExport<\n  UpdateInterfaceMethodHooks,\n  UpdateInterfaceParameters,\n  UpdateInterfaceResult\n> = {\n  methodNames: ['snap_updateInterface'],\n  implementation: getUpdateInterfaceImplementation,\n  hookNames,\n};\n\nconst UpdateInterfaceParametersStruct = object({\n  id: string(),\n  ui: ComponentStruct,\n});\n\nexport type UpdateInterfaceParameters = InferMatching<\n  typeof UpdateInterfaceParametersStruct,\n  UpdateInterfaceParams\n>;\n\n/**\n * The `snap_updateInterface` method implementation.\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.updateInterface - The function to update the interface.\n * @returns Nothing.\n */\nasync function getUpdateInterfaceImplementation(\n  req: JsonRpcRequest<UpdateInterfaceParameters>,\n  res: PendingJsonRpcResponse<UpdateInterfaceResult>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { updateInterface }: UpdateInterfaceMethodHooks,\n): Promise<void> {\n  const { params } = req;\n\n  try {\n    const validatedParams = getValidatedParams(params);\n\n    const { id, ui } = validatedParams;\n\n    await updateInterface(id, ui);\n    res.result = null;\n  } catch (error) {\n    return end(error);\n  }\n\n  return end();\n}\n\n/**\n * Validate the updateInterface method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated updateInterface method parameter object.\n */\nfunction getValidatedParams(params: unknown): UpdateInterfaceParameters {\n  try {\n    return create(params, UpdateInterfaceParametersStruct);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid params: ${error.message}.`,\n      });\n    }\n    /* istanbul ignore next */\n    throw rpcErrors.internal();\n  }\n}\n"],"names":["updateInterfaceHandler","hookNames","updateInterface","methodNames","implementation","getUpdateInterfaceImplementation","UpdateInterfaceParametersStruct","object","id","string","ui","ComponentStruct","req","res","_next","end","params","validatedParams","getValidatedParams","result","error","create","StructError","rpcErrors","invalidParams","message","internal"],"mappings":";;;;+BA4BaA;;;eAAAA;;;2BA1Ba;0BAOM;6BAGoB;AAIpD,MAAMC,YAA2D;IAC/DC,iBAAiB;AACnB;AAUO,MAAMF,yBAIT;IACFG,aAAa;QAAC;KAAuB;IACrCC,gBAAgBC;IAChBJ;AACF;AAEA,MAAMK,kCAAkCC,IAAAA,mBAAM,EAAC;IAC7CC,IAAIC,IAAAA,mBAAM;IACVC,IAAIC,yBAAe;AACrB;AAOA;;;;;;;;;;;CAWC,GACD,eAAeN,iCACbO,GAA8C,EAC9CC,GAAkD,EAClDC,KAAc,EACdC,GAA6B,EAC7B,EAAEb,eAAe,EAA8B;IAE/C,MAAM,EAAEc,MAAM,EAAE,GAAGJ;IAEnB,IAAI;QACF,MAAMK,kBAAkBC,mBAAmBF;QAE3C,MAAM,EAAER,EAAE,EAAEE,EAAE,EAAE,GAAGO;QAEnB,MAAMf,gBAAgBM,IAAIE;QAC1BG,IAAIM,MAAM,GAAG;IACf,EAAE,OAAOC,OAAO;QACd,OAAOL,IAAIK;IACb;IAEA,OAAOL;AACT;AAEA;;;;;;CAMC,GACD,SAASG,mBAAmBF,MAAe;IACzC,IAAI;QACF,OAAOK,IAAAA,mBAAM,EAACL,QAAQV;IACxB,EAAE,OAAOc,OAAO;QACd,IAAIA,iBAAiBE,wBAAW,EAAE;YAChC,MAAMC,oBAAS,CAACC,aAAa,CAAC;gBAC5BC,SAAS,CAAC,gBAAgB,EAAEL,MAAMK,OAAO,CAAC,CAAC,CAAC;YAC9C;QACF;QACA,wBAAwB,GACxB,MAAMF,oBAAS,CAACG,QAAQ;IAC1B;AACF"}