@metamask/snaps-execution-environments 0.24.0

package/dist/common/keyring.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapKeyring = void 0;
+const utils_1 = require("@metamask/utils");
+/**
+ * Wraps a SnapKeyring class, returning a handler that can route requests to the exposed functions by the class.
+ *
+ * @param notify - The BaseSnapExecutor notify function, used for event communication.
+ * @param keyring - The SnapKeyring instance.
+ * @returns A handler function.
+ */
+function wrapKeyring(notify, keyring) {
+    if (!keyring) {
+        throw new Error('Keyring not exported');
+    }
+    const keyringHandler = ({ request }) => {
+        const { method, params } = request;
+        if (!(method in keyring)) {
+            throw new Error(`Keyring does not expose ${method}`);
+        }
+        let args = (params !== null && params !== void 0 ? params : []);
+        const keyringMethod = keyring[method];
+        (0, utils_1.assert)(keyringMethod !== undefined);
+        const func = keyringMethod.bind(keyring);
+        // Special case for registering events
+        if (method === 'on') {
+            const data = args[0];
+            const listener = (...listenerArgs) => {
+                (0, utils_1.assert)((0, utils_1.isValidJson)(listenerArgs), new TypeError('Keyrings .on listener received non-JSON-serializable value.'));
+                return notify({
+                    method: 'SnapKeyringEvent',
+                    params: { data, args: listenerArgs },
+                });
+            };
+            args = [data, listener];
+        }
+        return func(...args);
+    };
+    return keyringHandler;
+}
+exports.wrapKeyring = wrapKeyring;
+//# sourceMappingURL=keyring.js.map

package/dist/common/keyring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring.js","sourceRoot":"","sources":["../../src/common/keyring.ts"],"names":[],"mappings":";;;AACA,2CAMyB;AAEzB;;;;;;GAMG;AACH,SAAgB,WAAW,CACzB,MAKS,EACT,OAAqB;IAErB,IAAI,CAAC,OAAO,EAAE;QACZ,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;KACzC;IAED,MAAM,cAAc,GAAG,CAAC,EAAE,OAAO,EAAuC,EAAE,EAAE;QAC1E,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QACnC,IAAI,CAAC,CAAC,MAAM,IAAI,OAAO,CAAC,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,2BAA2B,MAAM,EAAE,CAAC,CAAC;SACtD;QACD,IAAI,IAAI,GAAG,CAAC,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,CAAc,CAAC;QACvC,MAAM,aAAa,GAAG,OAAO,CAAC,MAA2B,CAAC,CAAC;QAC3D,IAAA,cAAM,EAAC,aAAa,KAAK,SAAS,CAAC,CAAC;QACpC,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACzC,sCAAsC;QACtC,IAAI,MAAM,KAAK,IAAI,EAAE;YACnB,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAS,CAAC;YAC7B,MAAM,QAAQ,GAAG,CAAC,GAAG,YAAuB,EAAE,EAAE;gBAC9C,IAAA,cAAM,EACJ,IAAA,mBAAW,EAAC,YAAY,CAAC,EACzB,IAAI,SAAS,CACX,6DAA6D,CAC9D,CACF,CAAC;gBACF,OAAO,MAAM,CAAC;oBACZ,MAAM,EAAE,kBAAkB;oBAC1B,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE;iBACrC,CAAC,CAAC;YACL,CAAC,CAAC;YACF,IAAI,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;SACzB;QACD,OAAQ,IAAqC,CAAC,GAAG,IAAI,CAAC,CAAC;IACzD,CAAC,CAAC;IACF,OAAO,cAAc,CAAC;AACxB,CAAC;AA1CD,kCA0CC","sourcesContent":["import { SnapKeyring } from '@metamask/snaps-types';\nimport {\n  assert,\n  isValidJson,\n  Json,\n  JsonRpcNotification,\n  JsonRpcRequest,\n} from '@metamask/utils';\n\n/**\n * Wraps a SnapKeyring class, returning a handler that can route requests to the exposed functions by the class.\n *\n * @param notify - The BaseSnapExecutor notify function, used for event communication.\n * @param keyring - The SnapKeyring instance.\n * @returns A handler function.\n */\nexport function wrapKeyring(\n  notify: (\n    requestObject: Omit<\n      JsonRpcNotification<Record<string, Json> | Json[]>,\n      'jsonrpc'\n    >,\n  ) => void,\n  keyring?: SnapKeyring,\n) {\n  if (!keyring) {\n    throw new Error('Keyring not exported');\n  }\n\n  const keyringHandler = ({ request }: { request: JsonRpcRequest<Json[]> }) => {\n    const { method, params } = request;\n    if (!(method in keyring)) {\n      throw new Error(`Keyring does not expose ${method}`);\n    }\n    let args = (params ?? []) as unknown[];\n    const keyringMethod = keyring[method as keyof SnapKeyring];\n    assert(keyringMethod !== undefined);\n    const func = keyringMethod.bind(keyring);\n    // Special case for registering events\n    if (method === 'on') {\n      const data = args[0] as Json;\n      const listener = (...listenerArgs: unknown[]) => {\n        assert(\n          isValidJson(listenerArgs),\n          new TypeError(\n            'Keyrings .on listener received non-JSON-serializable value.',\n          ),\n        );\n        return notify({\n          method: 'SnapKeyringEvent',\n          params: { data, args: listenerArgs },\n        });\n      };\n      args = [data, listener];\n    }\n    return (func as (..._: unknown[]) => unknown)(...args);\n  };\n  return keyringHandler;\n}\n"]}

package/dist/common/lockdown/lockdown-more.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="ses" />
+/**
+ * The SES `lockdown` function only hardens the properties enumerated by the
+ * universalPropertyNames constant specified in 'ses/src/whitelist'. This
+ * function makes all function and object properties on the start compartment
+ * global non-configurable and non-writable, unless they are already
+ * non-configurable.
+ *
+ * It is critical that this function runs at the right time during
+ * initialization, which should always be immediately after `lockdown` has been
+ * called. At the time of writing, the modifications this function makes to the
+ * runtime environment appear to be non-breaking, but that could change with
+ * the addition of dependencies, or the order of our scripts in our HTML files.
+ * Exercise caution.
+ *
+ * See inline comments for implementation details.
+ *
+ * We write this function in IIFE format to avoid polluting global scope.
+ *
+ * @throws If the lockdown failed.
+ */
+export declare function executeLockdownMore(): void;

package/dist/common/lockdown/lockdown-more.js

@@ -0,0 +1,88 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment
+/// <reference path="../../../../../node_modules/ses/index.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeLockdownMore = void 0;
+/**
+ * The SES `lockdown` function only hardens the properties enumerated by the
+ * universalPropertyNames constant specified in 'ses/src/whitelist'. This
+ * function makes all function and object properties on the start compartment
+ * global non-configurable and non-writable, unless they are already
+ * non-configurable.
+ *
+ * It is critical that this function runs at the right time during
+ * initialization, which should always be immediately after `lockdown` has been
+ * called. At the time of writing, the modifications this function makes to the
+ * runtime environment appear to be non-breaking, but that could change with
+ * the addition of dependencies, or the order of our scripts in our HTML files.
+ * Exercise caution.
+ *
+ * See inline comments for implementation details.
+ *
+ * We write this function in IIFE format to avoid polluting global scope.
+ *
+ * @throws If the lockdown failed.
+ */
+function executeLockdownMore() {
+    // Make all "object" and "function" own properties of globalThis
+    // non-configurable and non-writable, when possible.
+    // We call a property that is non-configurable and non-writable,
+    // "non-modifiable".
+    try {
+        const namedIntrinsics = Reflect.ownKeys(new Compartment().globalThis);
+        // These named intrinsics are not automatically hardened by `lockdown`
+        const shouldHardenManually = new Set(['eval', 'Function']);
+        const globalProperties = new Set([
+            // universalPropertyNames is a constant added by lockdown to global scope
+            // at the time of writing, it is initialized in 'ses/src/whitelist'.
+            // These properties tend to be non-enumerable.
+            ...namedIntrinsics,
+            // TODO: Also include the named platform globals
+            // This grabs every enumerable property on globalThis.
+            // ...Object.keys(globalThis),
+        ]);
+        globalProperties.forEach((propertyName) => {
+            const descriptor = Reflect.getOwnPropertyDescriptor(globalThis, propertyName);
+            if (descriptor) {
+                if (descriptor.configurable) {
+                    // If the property on globalThis is configurable, make it
+                    // non-configurable. If it has no accessor properties, also make it
+                    // non-writable.
+                    if (hasAccessor(descriptor)) {
+                        Object.defineProperty(globalThis, propertyName, {
+                            configurable: false,
+                        });
+                    }
+                    else {
+                        Object.defineProperty(globalThis, propertyName, {
+                            configurable: false,
+                            writable: false,
+                        });
+                    }
+                }
+                if (shouldHardenManually.has(propertyName)) {
+                    harden(globalThis[propertyName]);
+                }
+            }
+        });
+    }
+    catch (error) {
+        console.error('Protecting intrinsics failed:', error);
+        throw error;
+    }
+}
+exports.executeLockdownMore = executeLockdownMore;
+/**
+ * Checks whether the given propertyName descriptor has any accessors, i.e. the
+ * properties `get` or `set`.
+ *
+ * We want to make globals non-writable, and we can't set the `writable`
+ * property and accessor properties at the same time.
+ *
+ * @param descriptor - The propertyName descriptor to check.
+ * @returns Whether the propertyName descriptor has any accessors.
+ */
+function hasAccessor(descriptor) {
+    return 'set' in descriptor || 'get' in descriptor;
+}
+//# sourceMappingURL=lockdown-more.js.map

package/dist/common/lockdown/lockdown-more.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockdown-more.js","sourceRoot":"","sources":["../../../src/common/lockdown/lockdown-more.ts"],"names":[],"mappings":";AAAA,qFAAqF;AACrF,mEAAmE;;;AAEnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,mBAAmB;IACjC,gEAAgE;IAChE,oDAAoD;IACpD,gEAAgE;IAChE,oBAAoB;IACpB,IAAI;QACF,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,WAAW,EAAE,CAAC,UAAU,CAAC,CAAC;QAEtE,sEAAsE;QACtE,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAkB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;QAE5E,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;YAC/B,yEAAyE;YACzE,oEAAoE;YACpE,8CAA8C;YAC9C,GAAG,eAAe;YAElB,gDAAgD;YAChD,sDAAsD;YACtD,8BAA8B;SAC/B,CAAC,CAAC;QAEH,gBAAgB,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,EAAE;YACxC,MAAM,UAAU,GAAG,OAAO,CAAC,wBAAwB,CACjD,UAAU,EACV,YAAY,CACb,CAAC;YAEF,IAAI,UAAU,EAAE;gBACd,IAAI,UAAU,CAAC,YAAY,EAAE;oBAC3B,yDAAyD;oBACzD,mEAAmE;oBACnE,gBAAgB;oBAChB,IAAI,WAAW,CAAC,UAAU,CAAC,EAAE;wBAC3B,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,YAAY,EAAE;4BAC9C,YAAY,EAAE,KAAK;yBACpB,CAAC,CAAC;qBACJ;yBAAM;wBACL,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,YAAY,EAAE;4BAC9C,YAAY,EAAE,KAAK;4BACnB,QAAQ,EAAE,KAAK;yBAChB,CAAC,CAAC;qBACJ;iBACF;gBAED,IAAI,oBAAoB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;oBAC1C,MAAM,CAAE,UAAkB,CAAC,YAAY,CAAC,CAAC,CAAC;iBAC3C;aACF;QACH,CAAC,CAAC,CAAC;KACJ;IAAC,OAAO,KAAK,EAAE;QACd,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE,KAAK,CAAC,CAAC;QACtD,MAAM,KAAK,CAAC;KACb;AACH,CAAC;AAtDD,kDAsDC;AAED;;;;;;;;;GASG;AACH,SAAS,WAAW,CAAC,UAAe;IAClC,OAAO,KAAK,IAAI,UAAU,IAAI,KAAK,IAAI,UAAU,CAAC;AACpD,CAAC","sourcesContent":["// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment\n/// <reference path=\"../../../../../node_modules/ses/index.d.ts\" />\n\n/**\n * The SES `lockdown` function only hardens the properties enumerated by the\n * universalPropertyNames constant specified in 'ses/src/whitelist'. This\n * function makes all function and object properties on the start compartment\n * global non-configurable and non-writable, unless they are already\n * non-configurable.\n *\n * It is critical that this function runs at the right time during\n * initialization, which should always be immediately after `lockdown` has been\n * called. At the time of writing, the modifications this function makes to the\n * runtime environment appear to be non-breaking, but that could change with\n * the addition of dependencies, or the order of our scripts in our HTML files.\n * Exercise caution.\n *\n * See inline comments for implementation details.\n *\n * We write this function in IIFE format to avoid polluting global scope.\n *\n * @throws If the lockdown failed.\n */\nexport function executeLockdownMore() {\n  // Make all \"object\" and \"function\" own properties of globalThis\n  // non-configurable and non-writable, when possible.\n  // We call a property that is non-configurable and non-writable,\n  // \"non-modifiable\".\n  try {\n    const namedIntrinsics = Reflect.ownKeys(new Compartment().globalThis);\n\n    // These named intrinsics are not automatically hardened by `lockdown`\n    const shouldHardenManually = new Set<symbol | string>(['eval', 'Function']);\n\n    const globalProperties = new Set([\n      // universalPropertyNames is a constant added by lockdown to global scope\n      // at the time of writing, it is initialized in 'ses/src/whitelist'.\n      // These properties tend to be non-enumerable.\n      ...namedIntrinsics,\n\n      // TODO: Also include the named platform globals\n      // This grabs every enumerable property on globalThis.\n      // ...Object.keys(globalThis),\n    ]);\n\n    globalProperties.forEach((propertyName) => {\n      const descriptor = Reflect.getOwnPropertyDescriptor(\n        globalThis,\n        propertyName,\n      );\n\n      if (descriptor) {\n        if (descriptor.configurable) {\n          // If the property on globalThis is configurable, make it\n          // non-configurable. If it has no accessor properties, also make it\n          // non-writable.\n          if (hasAccessor(descriptor)) {\n            Object.defineProperty(globalThis, propertyName, {\n              configurable: false,\n            });\n          } else {\n            Object.defineProperty(globalThis, propertyName, {\n              configurable: false,\n              writable: false,\n            });\n          }\n        }\n\n        if (shouldHardenManually.has(propertyName)) {\n          harden((globalThis as any)[propertyName]);\n        }\n      }\n    });\n  } catch (error) {\n    console.error('Protecting intrinsics failed:', error);\n    throw error;\n  }\n}\n\n/**\n * Checks whether the given propertyName descriptor has any accessors, i.e. the\n * properties `get` or `set`.\n *\n * We want to make globals non-writable, and we can't set the `writable`\n * property and accessor properties at the same time.\n *\n * @param descriptor - The propertyName descriptor to check.\n * @returns Whether the propertyName descriptor has any accessors.\n */\nfunction hasAccessor(descriptor: any): boolean {\n  return 'set' in descriptor || 'get' in descriptor;\n}\n"]}

package/dist/common/lockdown/lockdown.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="ses" />
+/**
+ * Execute SES lockdown in the current context, i.e., the current iframe.
+ *
+ * @throws If the SES lockdown failed.
+ */
+export declare function executeLockdown(): void;

package/dist/common/lockdown/lockdown.js

@@ -0,0 +1,28 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment
+/// <reference path="../../../../../node_modules/ses/index.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeLockdown = void 0;
+/**
+ * Execute SES lockdown in the current context, i.e., the current iframe.
+ *
+ * @throws If the SES lockdown failed.
+ */
+function executeLockdown() {
+    try {
+        lockdown({
+            consoleTaming: 'unsafe',
+            errorTaming: 'unsafe',
+            mathTaming: 'unsafe',
+            dateTaming: 'unsafe',
+            overrideTaming: 'severe',
+        });
+    }
+    catch (error) {
+        // If the `lockdown` call throws an exception, it should not be able to continue
+        console.error('Lockdown failed:', error);
+        throw error;
+    }
+}
+exports.executeLockdown = executeLockdown;
+//# sourceMappingURL=lockdown.js.map

package/dist/common/lockdown/lockdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockdown.js","sourceRoot":"","sources":["../../../src/common/lockdown/lockdown.ts"],"names":[],"mappings":";AAAA,qFAAqF;AACrF,mEAAmE;;;AAEnE;;;;GAIG;AACH,SAAgB,eAAe;IAC7B,IAAI;QACF,QAAQ,CAAC;YACP,aAAa,EAAE,QAAQ;YACvB,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,QAAQ;YACpB,UAAU,EAAE,QAAQ;YACpB,cAAc,EAAE,QAAQ;SACzB,CAAC,CAAC;KACJ;IAAC,OAAO,KAAK,EAAE;QACd,gFAAgF;QAChF,OAAO,CAAC,KAAK,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;QACzC,MAAM,KAAK,CAAC;KACb;AACH,CAAC;AAdD,0CAcC","sourcesContent":["// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment\n/// <reference path=\"../../../../../node_modules/ses/index.d.ts\" />\n\n/**\n * Execute SES lockdown in the current context, i.e., the current iframe.\n *\n * @throws If the SES lockdown failed.\n */\nexport function executeLockdown() {\n  try {\n    lockdown({\n      consoleTaming: 'unsafe',\n      errorTaming: 'unsafe',\n      mathTaming: 'unsafe',\n      dateTaming: 'unsafe',\n      overrideTaming: 'severe',\n    });\n  } catch (error) {\n    // If the `lockdown` call throws an exception, it should not be able to continue\n    console.error('Lockdown failed:', error);\n    throw error;\n  }\n}\n"]}

package/dist/common/sortParams.d.ts

@@ -0,0 +1,16 @@
+import { JsonRpcParams } from '@metamask/utils';
+/**
+ * Deterministically sort JSON-RPC parameter keys. This makes it possible to
+ * support both arrays and objects as parameters. Objects are sorted and turned
+ * into arrays, for easier consumption by the snap.
+ *
+ * The order is defined by the `method` parameter.
+ *
+ * @param methodParams - The parameters of the JSON-RPC method, which
+ * determines the ordering for the parameters.
+ * @param params - JSON-RPC parameters as object or array.
+ * @returns The values for the sorted keys. If `params` is not provided, this
+ * returns an empty array. If `params` is an array, this returns the same
+ * `params`.
+ */
+export declare const sortParamKeys: (methodParams: string[], params?: JsonRpcParams) => import("@metamask/utils").Json[];

package/dist/common/sortParams.js

@@ -0,0 +1,32 @@
+"use strict";
+// original source sortParamKeys from: https://github.com/etclabscore/sig.tools/blob/master/src/postMessageServer/postMessageServer.ts#L75-L77
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortParamKeys = void 0;
+/**
+ * Deterministically sort JSON-RPC parameter keys. This makes it possible to
+ * support both arrays and objects as parameters. Objects are sorted and turned
+ * into arrays, for easier consumption by the snap.
+ *
+ * The order is defined by the `method` parameter.
+ *
+ * @param methodParams - The parameters of the JSON-RPC method, which
+ * determines the ordering for the parameters.
+ * @param params - JSON-RPC parameters as object or array.
+ * @returns The values for the sorted keys. If `params` is not provided, this
+ * returns an empty array. If `params` is an array, this returns the same
+ * `params`.
+ */
+const sortParamKeys = (methodParams, params) => {
+    if (!params) {
+        return [];
+    }
+    if (params instanceof Array) {
+        return params;
+    }
+    const methodParamsOrder = methodParams.reduce((paramsOrderObj, paramsName, i) => (Object.assign(Object.assign({}, paramsOrderObj), { [paramsName]: i })), {});
+    return Object.entries(params)
+        .sort(([name1, _], [name2, __]) => methodParamsOrder[name1] - methodParamsOrder[name2])
+        .map(([_, val]) => val);
+};
+exports.sortParamKeys = sortParamKeys;
+//# sourceMappingURL=sortParams.js.map

package/dist/common/sortParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortParams.js","sourceRoot":"","sources":["../../src/common/sortParams.ts"],"names":[],"mappings":";AAAA,8IAA8I;;;AAI9I;;;;;;;;;;;;;GAaG;AACI,MAAM,aAAa,GAAG,CAC3B,YAAsB,EACtB,MAAsB,EACtB,EAAE;IACF,IAAI,CAAC,MAAM,EAAE;QACX,OAAO,EAAE,CAAC;KACX;IAED,IAAI,MAAM,YAAY,KAAK,EAAE;QAC3B,OAAO,MAAM,CAAC;KACf;IAED,MAAM,iBAAiB,GAA4B,YAAY,CAAC,MAAM,CACpE,CAAC,cAAc,EAAE,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC,iCAC9B,cAAc,KACjB,CAAC,UAAU,CAAC,EAAE,CAAC,IACf,EACF,EAAE,CACH,CAAC;IAEF,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;SAC1B,IAAI,CACH,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,CAC1B,iBAAiB,CAAC,KAAK,CAAC,GAAG,iBAAiB,CAAC,KAAK,CAAC,CACtD;SACA,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;AAC5B,CAAC,CAAC;AA1BW,QAAA,aAAa,iBA0BxB","sourcesContent":["// original source sortParamKeys from: https://github.com/etclabscore/sig.tools/blob/master/src/postMessageServer/postMessageServer.ts#L75-L77\n\nimport { JsonRpcParams } from '@metamask/utils';\n\n/**\n * Deterministically sort JSON-RPC parameter keys. This makes it possible to\n * support both arrays and objects as parameters. Objects are sorted and turned\n * into arrays, for easier consumption by the snap.\n *\n * The order is defined by the `method` parameter.\n *\n * @param methodParams - The parameters of the JSON-RPC method, which\n * determines the ordering for the parameters.\n * @param params - JSON-RPC parameters as object or array.\n * @returns The values for the sorted keys. If `params` is not provided, this\n * returns an empty array. If `params` is an array, this returns the same\n * `params`.\n */\nexport const sortParamKeys = (\n  methodParams: string[],\n  params?: JsonRpcParams,\n) => {\n  if (!params) {\n    return [];\n  }\n\n  if (params instanceof Array) {\n    return params;\n  }\n\n  const methodParamsOrder: { [k: string]: number } = methodParams.reduce(\n    (paramsOrderObj, paramsName, i) => ({\n      ...paramsOrderObj,\n      [paramsName]: i,\n    }),\n    {},\n  );\n\n  return Object.entries(params)\n    .sort(\n      ([name1, _], [name2, __]) =>\n        methodParamsOrder[name1] - methodParamsOrder[name2],\n    )\n    .map(([_, val]) => val);\n};\n"]}

package/dist/common/utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Takes an error that was thrown, determines if it is
+ * an error object. If it is then it will return that. Otherwise,
+ * an error object is created with the original error message.
+ *
+ * @param originalError - The error that was originally thrown.
+ * @returns An error object.
+ */
+export declare function constructError(originalError: unknown): Error | undefined;
+/**
+ * Get all properties of an object, including its prototype chain.
+ *
+ * @param obj - The object to get all properties for.
+ * @returns All properties of `obj` as a tuple set, containing the property name
+ * and value.
+ */
+export declare function allProperties(obj: any): Set<[object, string | symbol]>;
+/**
+ * Get all functions of an object, including its prototype chain. This does not
+ * include constructor functions.
+ *
+ * @param obj - The object to get all functions for.
+ * @returns An array with all functions of `obj` as string or symbol.
+ */
+export declare function allFunctions(obj: any): (string | symbol)[];
+/**
+ * Make proxy for Promise and handle the teardown process properly.
+ * If the teardown is called in the meanwhile, Promise result will not be
+ * exposed to the snap anymore and warning will be logged to the console.
+ *
+ * @param originalPromise - Original promise.
+ * @param teardownRef - Reference containing teardown count.
+ * @param teardownRef.lastTeardown - Number of the last teardown.
+ * @returns New proxy promise.
+ */
+export declare function withTeardown<T>(originalPromise: Promise<T>, teardownRef: {
+    lastTeardown: number;
+}): Promise<T>;

package/dist/common/utils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTeardown = exports.allFunctions = exports.allProperties = exports.constructError = void 0;
+/**
+ * Takes an error that was thrown, determines if it is
+ * an error object. If it is then it will return that. Otherwise,
+ * an error object is created with the original error message.
+ *
+ * @param originalError - The error that was originally thrown.
+ * @returns An error object.
+ */
+function constructError(originalError) {
+    let _originalError;
+    if (originalError instanceof Error) {
+        _originalError = originalError;
+    }
+    else if (typeof originalError === 'string') {
+        _originalError = new Error(originalError);
+        // The stack is useless in this case.
+        delete _originalError.stack;
+    }
+    return _originalError;
+}
+exports.constructError = constructError;
+/**
+ * Get all properties of an object, including its prototype chain.
+ *
+ * @param obj - The object to get all properties for.
+ * @returns All properties of `obj` as a tuple set, containing the property name
+ * and value.
+ */
+function allProperties(obj) {
+    const properties = new Set();
+    let current = obj;
+    do {
+        for (const key of Reflect.ownKeys(current)) {
+            properties.add([current, key]);
+        }
+    } while ((current = Reflect.getPrototypeOf(current)) &&
+        current !== Object.prototype);
+    return properties;
+}
+exports.allProperties = allProperties;
+/**
+ * Get all functions of an object, including its prototype chain. This does not
+ * include constructor functions.
+ *
+ * @param obj - The object to get all functions for.
+ * @returns An array with all functions of `obj` as string or symbol.
+ */
+function allFunctions(obj) {
+    const result = [];
+    for (const [object, key] of allProperties(obj)) {
+        if (key === 'constructor') {
+            continue;
+        }
+        const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+        if (descriptor !== undefined && typeof descriptor.value === 'function') {
+            result.push(key);
+        }
+    }
+    return result;
+}
+exports.allFunctions = allFunctions;
+/**
+ * Make proxy for Promise and handle the teardown process properly.
+ * If the teardown is called in the meanwhile, Promise result will not be
+ * exposed to the snap anymore and warning will be logged to the console.
+ *
+ * @param originalPromise - Original promise.
+ * @param teardownRef - Reference containing teardown count.
+ * @param teardownRef.lastTeardown - Number of the last teardown.
+ * @returns New proxy promise.
+ */
+function withTeardown(originalPromise, teardownRef) {
+    const myTeardown = teardownRef.lastTeardown;
+    return new Promise((resolve, reject) => {
+        originalPromise
+            .then((value) => {
+            if (teardownRef.lastTeardown === myTeardown) {
+                resolve(value);
+            }
+            else {
+                console.warn('Late promise received after Snap finished execution. Promise will be dropped.');
+            }
+        })
+            .catch((reason) => {
+            if (teardownRef.lastTeardown === myTeardown) {
+                reject(reason);
+            }
+            else {
+                console.warn('Late promise received after Snap finished execution. Promise will be dropped.');
+            }
+        });
+    });
+}
+exports.withTeardown = withTeardown;
+//# sourceMappingURL=utils.js.map

package/dist/common/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/common/utils.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,aAAsB;IACnD,IAAI,cAAiC,CAAC;IACtC,IAAI,aAAa,YAAY,KAAK,EAAE;QAClC,cAAc,GAAG,aAAa,CAAC;KAChC;SAAM,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE;QAC5C,cAAc,GAAG,IAAI,KAAK,CAAC,aAAa,CAAC,CAAC;QAC1C,qCAAqC;QACrC,OAAO,cAAc,CAAC,KAAK,CAAC;KAC7B;IACD,OAAO,cAAc,CAAC;AACxB,CAAC;AAVD,wCAUC;AAED;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,GAAQ;IACpC,MAAM,UAAU,GAAG,IAAI,GAAG,EAAc,CAAC;IACzC,IAAI,OAAO,GAAG,GAAG,CAAC;IAClB,GAAG;QACD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC1C,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;SAChC;KACF,QACC,CAAC,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC3C,OAAO,KAAK,MAAM,CAAC,SAAS,EAC5B;IACF,OAAO,UAAU,CAAC;AACpB,CAAC;AAZD,sCAYC;AAED;;;;;;GAMG;AACH,SAAgB,YAAY,CAAC,GAAQ;IACnC,MAAM,MAAM,GAAG,EAAE,CAAC;IAClB,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,EAAE;QAC9C,IAAI,GAAG,KAAK,aAAa,EAAE;YACzB,SAAS;SACV;QACD,MAAM,UAAU,GAAG,OAAO,CAAC,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACjE,IAAI,UAAU,KAAK,SAAS,IAAI,OAAO,UAAU,CAAC,KAAK,KAAK,UAAU,EAAE;YACtE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SAClB;KACF;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAZD,oCAYC;AAED;;;;;;;;;GASG;AACH,SAAgB,YAAY,CAC1B,eAA2B,EAC3B,WAAqC;IAErC,MAAM,UAAU,GAAG,WAAW,CAAC,YAAY,CAAC;IAC5C,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,eAAe;aACZ,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YACd,IAAI,WAAW,CAAC,YAAY,KAAK,UAAU,EAAE;gBAC3C,OAAO,CAAC,KAAK,CAAC,CAAC;aAChB;iBAAM;gBACL,OAAO,CAAC,IAAI,CACV,+EAA+E,CAChF,CAAC;aACH;QACH,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE;YAChB,IAAI,WAAW,CAAC,YAAY,KAAK,UAAU,EAAE;gBAC3C,MAAM,CAAC,MAAM,CAAC,CAAC;aAChB;iBAAM;gBACL,OAAO,CAAC,IAAI,CACV,+EAA+E,CAChF,CAAC;aACH;QACH,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACL,CAAC;AA1BD,oCA0BC","sourcesContent":["/**\n * Takes an error that was thrown, determines if it is\n * an error object. If it is then it will return that. Otherwise,\n * an error object is created with the original error message.\n *\n * @param originalError - The error that was originally thrown.\n * @returns An error object.\n */\nexport function constructError(originalError: unknown) {\n  let _originalError: Error | undefined;\n  if (originalError instanceof Error) {\n    _originalError = originalError;\n  } else if (typeof originalError === 'string') {\n    _originalError = new Error(originalError);\n    // The stack is useless in this case.\n    delete _originalError.stack;\n  }\n  return _originalError;\n}\n\n/**\n * Get all properties of an object, including its prototype chain.\n *\n * @param obj - The object to get all properties for.\n * @returns All properties of `obj` as a tuple set, containing the property name\n * and value.\n */\nexport function allProperties(obj: any): Set<[object, string | symbol]> {\n  const properties = new Set<[any, any]>();\n  let current = obj;\n  do {\n    for (const key of Reflect.ownKeys(current)) {\n      properties.add([current, key]);\n    }\n  } while (\n    (current = Reflect.getPrototypeOf(current)) &&\n    current !== Object.prototype\n  );\n  return properties;\n}\n\n/**\n * Get all functions of an object, including its prototype chain. This does not\n * include constructor functions.\n *\n * @param obj - The object to get all functions for.\n * @returns An array with all functions of `obj` as string or symbol.\n */\nexport function allFunctions(obj: any): (string | symbol)[] {\n  const result = [];\n  for (const [object, key] of allProperties(obj)) {\n    if (key === 'constructor') {\n      continue;\n    }\n    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);\n    if (descriptor !== undefined && typeof descriptor.value === 'function') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Make proxy for Promise and handle the teardown process properly.\n * If the teardown is called in the meanwhile, Promise result will not be\n * exposed to the snap anymore and warning will be logged to the console.\n *\n * @param originalPromise - Original promise.\n * @param teardownRef - Reference containing teardown count.\n * @param teardownRef.lastTeardown - Number of the last teardown.\n * @returns New proxy promise.\n */\nexport function withTeardown<T>(\n  originalPromise: Promise<T>,\n  teardownRef: { lastTeardown: number },\n): Promise<T> {\n  const myTeardown = teardownRef.lastTeardown;\n  return new Promise<T>((resolve, reject) => {\n    originalPromise\n      .then((value) => {\n        if (teardownRef.lastTeardown === myTeardown) {\n          resolve(value);\n        } else {\n          console.warn(\n            'Late promise received after Snap finished execution. Promise will be dropped.',\n          );\n        }\n      })\n      .catch((reason) => {\n        if (teardownRef.lastTeardown === myTeardown) {\n          reject(reason);\n        } else {\n          console.warn(\n            'Late promise received after Snap finished execution. Promise will be dropped.',\n          );\n        }\n      });\n  });\n}\n"]}

package/dist/common/validation.d.ts

@@ -0,0 +1,100 @@
+import { HandlerType } from '@metamask/snaps-utils';
+import { Json, JsonRpcSuccess } from '@metamask/utils';
+import { Infer } from 'superstruct';
+/**
+ * Validates a given snap export.
+ *
+ * @param type - The type of export expected.
+ * @param snapExport - The export itself.
+ * @returns True if the export matches the expected shape, false otherwise.
+ */
+export declare function validateExport(type: HandlerType, snapExport: unknown): boolean;
+export declare const JsonRpcRequestWithoutIdStruct: import("superstruct").Struct<{
+    jsonrpc: "2.0";
+    method: string;
+    id?: string | number | null | undefined;
+    params?: Record<string, Json> | Json[] | undefined;
+}, {
+    id: import("superstruct").Struct<string | number | null | undefined, null>;
+    jsonrpc: import("superstruct").Struct<"2.0", "2.0">;
+    method: import("superstruct").Struct<string, null>;
+    params: import("superstruct").Struct<Record<string, Json> | Json[] | undefined, null>;
+}>;
+export declare type JsonRpcRequestWithoutId = Infer<typeof JsonRpcRequestWithoutIdStruct>;
+export declare const EndowmentStruct: import("superstruct").Struct<string, null>;
+export declare type Endowment = Infer<typeof EndowmentStruct>;
+/**
+ * Check if the given value is an endowment.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is an endowment.
+ */
+export declare function isEndowment(value: unknown): value is Endowment;
+/**
+ * Check if the given value is an array of endowments.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is an array of endowments.
+ */
+export declare function isEndowmentsArray(value: unknown): value is Endowment[];
+export declare const PingRequestArgumentsStruct: import("superstruct").Struct<unknown[] | undefined, null>;
+export declare const TerminateRequestArgumentsStruct: import("superstruct").Struct<unknown[] | undefined, null>;
+export declare const ExecuteSnapRequestArgumentsStruct: import("superstruct").Struct<[string, string, string[] | undefined], null>;
+export declare const SnapRpcRequestArgumentsStruct: import("superstruct").Struct<[string, HandlerType, string, {
+    jsonrpc: "2.0";
+    method: string;
+    id?: string | number | null | undefined;
+    params?: Record<string, Json> | undefined;
+}], null>;
+export declare type PingRequestArguments = Infer<typeof PingRequestArgumentsStruct>;
+export declare type TerminateRequestArguments = Infer<typeof TerminateRequestArgumentsStruct>;
+export declare type ExecuteSnapRequestArguments = Infer<typeof ExecuteSnapRequestArgumentsStruct>;
+export declare type SnapRpcRequestArguments = Infer<typeof SnapRpcRequestArgumentsStruct>;
+export declare type RequestArguments = PingRequestArguments | TerminateRequestArguments | ExecuteSnapRequestArguments | SnapRpcRequestArguments;
+export declare const OnTransactionRequestArgumentsStruct: import("superstruct").Struct<{
+    chainId: string;
+    transaction: Record<string, Json>;
+    transactionOrigin: string | null;
+}, {
+    transaction: import("superstruct").Struct<Record<string, Json>, null>;
+    chainId: import("superstruct").Struct<string, null>;
+    transactionOrigin: import("superstruct").Struct<string | null, null>;
+}>;
+export declare type OnTransactionRequestArguments = Infer<typeof OnTransactionRequestArgumentsStruct>;
+/**
+ * Asserts that the given value is a valid {@link OnTransactionRequestArguments}
+ * object.
+ *
+ * @param value - The value to validate.
+ * @throws If the value is not a valid {@link OnTransactionRequestArguments}
+ * object.
+ */
+export declare function assertIsOnTransactionRequestArguments(value: unknown): asserts value is OnTransactionRequestArguments;
+declare const OkResponseStruct: import("superstruct").Struct<{
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result: "OK";
+}, {
+    result: import("superstruct").Struct<"OK", "OK">;
+    jsonrpc: import("superstruct").Struct<"2.0", "2.0">;
+    id: import("superstruct").Struct<string | number | null, null>;
+}>;
+declare const SnapRpcResponse: import("superstruct").Struct<{
+    id: string | number | null;
+    jsonrpc: "2.0";
+    result: Json;
+}, {
+    id: import("superstruct").Struct<string | number | null, null>;
+    jsonrpc: import("superstruct").Struct<"2.0", "2.0">;
+    result: import("superstruct").Struct<Json, null>;
+}>;
+export declare type OkResponse = Infer<typeof OkResponseStruct>;
+export declare type SnapRpcResponse = Infer<typeof SnapRpcResponse>;
+export declare type Response = OkResponse | SnapRpcResponse;
+declare type RequestParams<Params extends unknown[] | undefined> = Params extends undefined ? [] : Params;
+declare type RequestFunction<Args extends RequestArguments, ResponseType extends JsonRpcSuccess<Json>> = (...args: RequestParams<Args>) => Promise<ResponseType['result']>;
+export declare type Ping = RequestFunction<PingRequestArguments, OkResponse>;
+export declare type Terminate = RequestFunction<TerminateRequestArguments, OkResponse>;
+export declare type ExecuteSnap = RequestFunction<ExecuteSnapRequestArguments, OkResponse>;
+export declare type SnapRpc = RequestFunction<SnapRpcRequestArguments, SnapRpcResponse>;
+export {};

package/dist/common/validation.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsOnTransactionRequestArguments = exports.OnTransactionRequestArgumentsStruct = exports.SnapRpcRequestArgumentsStruct = exports.ExecuteSnapRequestArgumentsStruct = exports.TerminateRequestArgumentsStruct = exports.PingRequestArgumentsStruct = exports.isEndowmentsArray = exports.isEndowment = exports.EndowmentStruct = exports.JsonRpcRequestWithoutIdStruct = exports.validateExport = void 0;
+const snaps_utils_1 = require("@metamask/snaps-utils");
+const utils_1 = require("@metamask/utils");
+const superstruct_1 = require("superstruct");
+const VALIDATION_FUNCTIONS = {
+    [snaps_utils_1.HandlerType.OnRpcRequest]: validateFunctionExport,
+    [snaps_utils_1.HandlerType.OnTransaction]: validateFunctionExport,
+    [snaps_utils_1.HandlerType.SnapKeyring]: validateKeyringExport,
+    [snaps_utils_1.HandlerType.OnCronjob]: validateFunctionExport,
+};
+/**
+ * Validates a function export.
+ *
+ * @param snapExport - The export itself.
+ * @returns True if the export matches the expected shape, false otherwise.
+ */
+function validateFunctionExport(snapExport) {
+    return typeof snapExport === 'function';
+}
+/**
+ * Validates a keyring export.
+ *
+ * @param snapExport - The export itself.
+ * @returns True if the export matches the expected shape, false otherwise.
+ */
+function validateKeyringExport(snapExport) {
+    // TODO Decide whether we want more validation
+    return typeof snapExport === 'object';
+}
+/**
+ * Validates a given snap export.
+ *
+ * @param type - The type of export expected.
+ * @param snapExport - The export itself.
+ * @returns True if the export matches the expected shape, false otherwise.
+ */
+function validateExport(type, snapExport) {
+    var _a;
+    const validationFunction = VALIDATION_FUNCTIONS[type];
+    return (_a = validationFunction === null || validationFunction === void 0 ? void 0 : validationFunction(snapExport)) !== null && _a !== void 0 ? _a : false;
+}
+exports.validateExport = validateExport;
+exports.JsonRpcRequestWithoutIdStruct = (0, superstruct_1.assign)((0, superstruct_1.omit)(utils_1.JsonRpcRequestStruct, ['id']), (0, superstruct_1.object)({
+    id: (0, superstruct_1.optional)(utils_1.JsonRpcIdStruct),
+}));
+exports.EndowmentStruct = (0, superstruct_1.string)();
+/**
+ * Check if the given value is an endowment.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is an endowment.
+ */
+function isEndowment(value) {
+    return (0, superstruct_1.is)(value, exports.EndowmentStruct);
+}
+exports.isEndowment = isEndowment;
+/**
+ * Check if the given value is an array of endowments.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is an array of endowments.
+ */
+function isEndowmentsArray(value) {
+    return Array.isArray(value) && value.every(isEndowment);
+}
+exports.isEndowmentsArray = isEndowmentsArray;
+const OkStruct = (0, superstruct_1.literal)('OK');
+exports.PingRequestArgumentsStruct = (0, superstruct_1.optional)((0, superstruct_1.union)([(0, superstruct_1.literal)(undefined), (0, superstruct_1.array)()]));
+exports.TerminateRequestArgumentsStruct = (0, superstruct_1.union)([
+    (0, superstruct_1.literal)(undefined),
+    (0, superstruct_1.array)(),
+]);
+exports.ExecuteSnapRequestArgumentsStruct = (0, superstruct_1.tuple)([
+    (0, superstruct_1.string)(),
+    (0, superstruct_1.string)(),
+    (0, superstruct_1.optional)((0, superstruct_1.array)(exports.EndowmentStruct)),
+]);
+exports.SnapRpcRequestArgumentsStruct = (0, superstruct_1.tuple)([
+    (0, superstruct_1.string)(),
+    (0, superstruct_1.enums)(Object.values(snaps_utils_1.HandlerType)),
+    (0, superstruct_1.string)(),
+    (0, superstruct_1.assign)(exports.JsonRpcRequestWithoutIdStruct, (0, superstruct_1.object)({
+        params: (0, superstruct_1.optional)((0, superstruct_1.record)((0, superstruct_1.string)(), utils_1.JsonStruct)),
+    })),
+]);
+exports.OnTransactionRequestArgumentsStruct = (0, superstruct_1.object)({
+    // TODO: Improve `transaction` type.
+    transaction: (0, superstruct_1.record)((0, superstruct_1.string)(), utils_1.JsonStruct),
+    chainId: snaps_utils_1.ChainIdStruct,
+    transactionOrigin: (0, superstruct_1.nullable)((0, superstruct_1.string)()),
+});
+/**
+ * Asserts that the given value is a valid {@link OnTransactionRequestArguments}
+ * object.
+ *
+ * @param value - The value to validate.
+ * @throws If the value is not a valid {@link OnTransactionRequestArguments}
+ * object.
+ */
+function assertIsOnTransactionRequestArguments(value) {
+    (0, utils_1.assertStruct)(value, exports.OnTransactionRequestArgumentsStruct, 'Invalid request params');
+}
+exports.assertIsOnTransactionRequestArguments = assertIsOnTransactionRequestArguments;
+const OkResponseStruct = (0, superstruct_1.assign)(utils_1.JsonRpcSuccessStruct, (0, superstruct_1.object)({
+    result: OkStruct,
+}));
+const SnapRpcResponse = utils_1.JsonRpcSuccessStruct;
+//# sourceMappingURL=validation.js.map