@metamask/snaps-execution-environments 1.0.1 → 2.0.0

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

@@ -0,0 +1,73 @@
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment
+/// <reference path="../../../../../node_modules/ses/types.d.ts" />
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "executeLockdownMore", {
+    enumerable: true,
+    get: function() {
+        return executeLockdownMore;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+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
+        ]);
+        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) {
+        (0, _snapsutils.logError)('Protecting intrinsics failed:', error);
+        throw error;
+    }
+}
+/**
+ * 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/cjs/common/lockdown/lockdown-more.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/common/lockdown/lockdown-more.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment\n/// <reference path=\"../../../../../node_modules/ses/types.d.ts\" />\n\nimport { logError } from '@metamask/snaps-utils';\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    logError('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"],"names":["executeLockdownMore","namedIntrinsics","Reflect","ownKeys","Compartment","globalThis","shouldHardenManually","Set","globalProperties","forEach","propertyName","descriptor","getOwnPropertyDescriptor","configurable","hasAccessor","Object","defineProperty","writable","has","harden","error","logError"],"mappings":"AAAA,qFAAqF;AACrF,mEAAmE;;;;;+BAwBnDA;;;eAAAA;;;4BAtBS;AAsBlB,SAASA;IACd,gEAAgE;IAChE,oDAAoD;IACpD,gEAAgE;IAChE,oBAAoB;IACpB,IAAI;QACF,MAAMC,kBAAkBC,QAAQC,OAAO,CAAC,IAAIC,cAAcC,UAAU;QAEpE,sEAAsE;QACtE,MAAMC,uBAAuB,IAAIC,IAAqB;YAAC;YAAQ;SAAW;QAE1E,MAAMC,mBAAmB,IAAID,IAAI;YAC/B,yEAAyE;YACzE,oEAAoE;YACpE,8CAA8C;eAC3CN;SAKJ;QAEDO,iBAAiBC,OAAO,CAAC,CAACC;YACxB,MAAMC,aAAaT,QAAQU,wBAAwB,CACjDP,YACAK;YAGF,IAAIC,YAAY;gBACd,IAAIA,WAAWE,YAAY,EAAE;oBAC3B,yDAAyD;oBACzD,mEAAmE;oBACnE,gBAAgB;oBAChB,IAAIC,YAAYH,aAAa;wBAC3BI,OAAOC,cAAc,CAACX,YAAYK,cAAc;4BAC9CG,cAAc;wBAChB;oBACF,OAAO;wBACLE,OAAOC,cAAc,CAACX,YAAYK,cAAc;4BAC9CG,cAAc;4BACdI,UAAU;wBACZ;oBACF;gBACF;gBAEA,IAAIX,qBAAqBY,GAAG,CAACR,eAAe;oBAC1CS,OAAO,AAACd,UAAkB,CAACK,aAAa;gBAC1C;YACF;QACF;IACF,EAAE,OAAOU,OAAO;QACdC,IAAAA,oBAAQ,EAAC,iCAAiCD;QAC1C,MAAMA;IACR;AACF;AAEA;;;;;;;;;CASC,GACD,SAASN,YAAYH,UAAe;IAClC,OAAO,SAASA,cAAc,SAASA;AACzC"}

package/dist/cjs/common/lockdown/lockdown.js

@@ -0,0 +1,30 @@
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment
+/// <reference path="../../../../../node_modules/ses/types.d.ts" />
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "executeLockdown", {
+    enumerable: true,
+    get: function() {
+        return executeLockdown;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+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
+        (0, _snapsutils.logError)('Lockdown failed:', error);
+        throw error;
+    }
+}
+
+//# sourceMappingURL=lockdown.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/common/lockdown/lockdown.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment\n/// <reference path=\"../../../../../node_modules/ses/types.d.ts\" />\n\nimport { logError } from '@metamask/snaps-utils';\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    logError('Lockdown failed:', error);\n    throw error;\n  }\n}\n"],"names":["executeLockdown","lockdown","consoleTaming","errorTaming","mathTaming","dateTaming","overrideTaming","error","logError"],"mappings":"AAAA,qFAAqF;AACrF,mEAAmE;;;;;+BASnDA;;;eAAAA;;;4BAPS;AAOlB,SAASA;IACd,IAAI;QACFC,SAAS;YACPC,eAAe;YACfC,aAAa;YACbC,YAAY;YACZC,YAAY;YACZC,gBAAgB;QAClB;IACF,EAAE,OAAOC,OAAO;QACd,gFAAgF;QAChFC,IAAAA,oBAAQ,EAAC,oBAAoBD;QAC7B,MAAMA;IACR;AACF"}

package/dist/cjs/common/sortParams.js

@@ -0,0 +1,26 @@
+// original source sortParamKeys from: https://github.com/etclabscore/sig.tools/blob/master/src/postMessageServer/postMessageServer.ts#L75-L77
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "sortParamKeys", {
+    enumerable: true,
+    get: function() {
+        return sortParamKeys;
+    }
+});
+const sortParamKeys = (methodParams, params)=>{
+    if (!params) {
+        return [];
+    }
+    if (params instanceof Array) {
+        return params;
+    }
+    const methodParamsOrder = methodParams.reduce((paramsOrderObj, paramsName, i)=>({
+            ...paramsOrderObj,
+            [paramsName]: i
+        }), {});
+    return Object.entries(params).sort(([name1, _1], [name2, _2])=>methodParamsOrder[name1] - methodParamsOrder[name2]).map(([_, val])=>val);
+};
+
+//# sourceMappingURL=sortParams.js.map

package/dist/cjs/common/sortParams.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/common/sortParams.ts"],"sourcesContent":["// original source sortParamKeys from: https://github.com/etclabscore/sig.tools/blob/master/src/postMessageServer/postMessageServer.ts#L75-L77\n\nimport type { 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, _1], [name2, _2]) =>\n        methodParamsOrder[name1] - methodParamsOrder[name2],\n    )\n    .map(([_, val]) => val);\n};\n"],"names":["sortParamKeys","methodParams","params","Array","methodParamsOrder","reduce","paramsOrderObj","paramsName","i","Object","entries","sort","name1","_1","name2","_2","map","_","val"],"mappings":"AAAA,8IAA8I;;;;;+BAkBjIA;;;eAAAA;;;AAAN,MAAMA,gBAAgB,CAC3BC,cACAC;IAEA,IAAI,CAACA,QAAQ;QACX,OAAO,EAAE;IACX;IAEA,IAAIA,kBAAkBC,OAAO;QAC3B,OAAOD;IACT;IAEA,MAAME,oBAA6CH,aAAaI,MAAM,CACpE,CAACC,gBAAgBC,YAAYC,IAAO,CAAA;YAClC,GAAGF,cAAc;YACjB,CAACC,WAAW,EAAEC;QAChB,CAAA,GACA,CAAC;IAGH,OAAOC,OAAOC,OAAO,CAACR,QACnBS,IAAI,CACH,CAAC,CAACC,OAAOC,GAAG,EAAE,CAACC,OAAOC,GAAG,GACvBX,iBAAiB,CAACQ,MAAM,GAAGR,iBAAiB,CAACU,MAAM,EAEtDE,GAAG,CAAC,CAAC,CAACC,GAAGC,IAAI,GAAKA;AACvB"}

package/dist/cjs/common/utils.js

@@ -0,0 +1,132 @@
+"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, {
+    constructError: function() {
+        return constructError;
+    },
+    withTeardown: function() {
+        return withTeardown;
+    },
+    proxyStreamProvider: function() {
+        return proxyStreamProvider;
+    },
+    BLOCKED_RPC_METHODS: function() {
+        return BLOCKED_RPC_METHODS;
+    },
+    assertSnapOutboundRequest: function() {
+        return assertSnapOutboundRequest;
+    },
+    assertEthereumOutboundRequest: function() {
+        return assertEthereumOutboundRequest;
+    }
+});
+const _utils = require("@metamask/utils");
+const _ethrpcerrors = require("eth-rpc-errors");
+const _logging = require("../logging");
+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;
+}
+async function withTeardown(originalPromise, teardownRef) {
+    const myTeardown = teardownRef.lastTeardown;
+    return new Promise((resolve, reject)=>{
+        originalPromise.then((value)=>{
+            if (teardownRef.lastTeardown === myTeardown) {
+                resolve(value);
+            } else {
+                (0, _logging.log)('Late promise received after Snap finished execution. Promise will be dropped.');
+            }
+        }).catch((reason)=>{
+            if (teardownRef.lastTeardown === myTeardown) {
+                reject(reason);
+            } else {
+                (0, _logging.log)('Late promise received after Snap finished execution. Promise will be dropped.');
+            }
+        });
+    });
+}
+function proxyStreamProvider(provider, request) {
+    // Proxy target is intentionally set to be an empty object, to ensure
+    // that access to the prototype chain is not possible.
+    const proxy = new Proxy({}, {
+        has (_target, prop) {
+            return typeof prop === 'string' && [
+                'request',
+                'on',
+                'removeListener'
+            ].includes(prop);
+        },
+        get (_target, prop) {
+            if (prop === 'request') {
+                return request;
+            } else if ([
+                'on',
+                'removeListener'
+            ].includes(prop)) {
+                return provider[prop];
+            }
+            return undefined;
+        }
+    });
+    return proxy;
+}
+const BLOCKED_RPC_METHODS = Object.freeze([
+    'wallet_requestSnaps',
+    'wallet_requestPermissions',
+    // We disallow all of these confirmations for now, since the screens are not ready for Snaps.
+    'eth_sendRawTransaction',
+    'eth_sendTransaction',
+    'eth_sign',
+    'eth_signTypedData',
+    'eth_signTypedData_v1',
+    'eth_signTypedData_v3',
+    'eth_signTypedData_v4',
+    'eth_decrypt',
+    'eth_getEncryptionPublicKey',
+    'wallet_addEthereumChain',
+    'wallet_switchEthereumChain',
+    'wallet_watchAsset',
+    'wallet_registerOnboarding',
+    'wallet_scanQRCode'
+]);
+function assertSnapOutboundRequest(args) {
+    // Disallow any non `wallet_` or `snap_` methods for separation of concerns.
+    (0, _utils.assert)(String.prototype.startsWith.call(args.method, 'wallet_') || String.prototype.startsWith.call(args.method, 'snap_'), 'The global Snap API only allows RPC methods starting with `wallet_*` and `snap_*`.');
+    (0, _utils.assert)(!BLOCKED_RPC_METHODS.includes(args.method), _ethrpcerrors.ethErrors.rpc.methodNotFound({
+        data: {
+            method: args.method
+        }
+    }));
+    (0, _utils.assertStruct)(args, _utils.JsonStruct, 'Provided value is not JSON-RPC compatible');
+}
+function assertEthereumOutboundRequest(args) {
+    // Disallow snaps methods for separation of concerns.
+    (0, _utils.assert)(!String.prototype.startsWith.call(args.method, 'snap_'), _ethrpcerrors.ethErrors.rpc.methodNotFound({
+        data: {
+            method: args.method
+        }
+    }));
+    (0, _utils.assert)(!BLOCKED_RPC_METHODS.includes(args.method), _ethrpcerrors.ethErrors.rpc.methodNotFound({
+        data: {
+            method: args.method
+        }
+    }));
+    (0, _utils.assertStruct)(args, _utils.JsonStruct, 'Provided value is not JSON-RPC compatible');
+}
+
+//# sourceMappingURL=utils.js.map

package/dist/cjs/common/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/common/utils.ts"],"sourcesContent":["import type { StreamProvider } from '@metamask/providers';\nimport type { RequestArguments } from '@metamask/providers/dist/BaseProvider';\nimport { assert, assertStruct, JsonStruct } from '@metamask/utils';\nimport { ethErrors } from 'eth-rpc-errors';\n\nimport { log } from '../logging';\n\n/**\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 * 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 async function withTeardown<Type>(\n  originalPromise: Promise<Type>,\n  teardownRef: { lastTeardown: number },\n): Promise<Type> {\n  const myTeardown = teardownRef.lastTeardown;\n  return new Promise<Type>((resolve, reject) => {\n    originalPromise\n      .then((value) => {\n        if (teardownRef.lastTeardown === myTeardown) {\n          resolve(value);\n        } else {\n          log(\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          log(\n            'Late promise received after Snap finished execution. Promise will be dropped.',\n          );\n        }\n      });\n  });\n}\n\n/**\n * Returns a Proxy that narrows down (attenuates) the fields available on\n * the StreamProvider and replaces the request implementation.\n *\n * @param provider - Instance of a StreamProvider to be limited.\n * @param request - Custom attenuated request object.\n * @returns Proxy to the StreamProvider instance.\n */\nexport function proxyStreamProvider(\n  provider: StreamProvider,\n  request: unknown,\n): StreamProvider {\n  // Proxy target is intentionally set to be an empty object, to ensure\n  // that access to the prototype chain is not possible.\n  const proxy = new Proxy(\n    {},\n    {\n      has(_target: object, prop: string | symbol) {\n        return (\n          typeof prop === 'string' &&\n          ['request', 'on', 'removeListener'].includes(prop)\n        );\n      },\n      get(_target, prop: keyof StreamProvider) {\n        if (prop === 'request') {\n          return request;\n        } else if (['on', 'removeListener'].includes(prop)) {\n          return provider[prop];\n        }\n\n        return undefined;\n      },\n    },\n  );\n\n  return proxy as StreamProvider;\n}\n\n// We're blocking these RPC methods for v1, will revisit later.\nexport const BLOCKED_RPC_METHODS = Object.freeze([\n  'wallet_requestSnaps',\n  'wallet_requestPermissions',\n  // We disallow all of these confirmations for now, since the screens are not ready for Snaps.\n  'eth_sendRawTransaction',\n  'eth_sendTransaction',\n  'eth_sign',\n  'eth_signTypedData',\n  'eth_signTypedData_v1',\n  'eth_signTypedData_v3',\n  'eth_signTypedData_v4',\n  'eth_decrypt',\n  'eth_getEncryptionPublicKey',\n  'wallet_addEthereumChain',\n  'wallet_switchEthereumChain',\n  'wallet_watchAsset',\n  'wallet_registerOnboarding',\n  'wallet_scanQRCode',\n]);\n\n/**\n * Asserts the validity of request arguments for a snap outbound request using the `snap.request` API.\n *\n * @param args - The arguments to validate.\n */\nexport function assertSnapOutboundRequest(args: RequestArguments) {\n  // Disallow any non `wallet_` or `snap_` methods for separation of concerns.\n  assert(\n    String.prototype.startsWith.call(args.method, 'wallet_') ||\n      String.prototype.startsWith.call(args.method, 'snap_'),\n    'The global Snap API only allows RPC methods starting with `wallet_*` and `snap_*`.',\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    ethErrors.rpc.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(args, JsonStruct, 'Provided value is not JSON-RPC compatible');\n}\n\n/**\n * Asserts the validity of request arguments for an ethereum outbound request using the `ethereum.request` API.\n *\n * @param args - The arguments to validate.\n */\nexport function assertEthereumOutboundRequest(args: RequestArguments) {\n  // Disallow snaps methods for separation of concerns.\n  assert(\n    !String.prototype.startsWith.call(args.method, 'snap_'),\n    ethErrors.rpc.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    ethErrors.rpc.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(args, JsonStruct, 'Provided value is not JSON-RPC compatible');\n}\n"],"names":["constructError","withTeardown","proxyStreamProvider","BLOCKED_RPC_METHODS","assertSnapOutboundRequest","assertEthereumOutboundRequest","originalError","_originalError","Error","stack","originalPromise","teardownRef","myTeardown","lastTeardown","Promise","resolve","reject","then","value","log","catch","reason","provider","request","proxy","Proxy","has","_target","prop","includes","get","undefined","Object","freeze","args","assert","String","prototype","startsWith","call","method","ethErrors","rpc","methodNotFound","data","assertStruct","JsonStruct"],"mappings":";;;;;;;;;;;IAegBA,cAAc;eAAdA;;IAsBMC,YAAY;eAAZA;;IAoCNC,mBAAmB;eAAnBA;;IA+BHC,mBAAmB;eAAnBA;;IAyBGC,yBAAyB;eAAzBA;;IAuBAC,6BAA6B;eAA7BA;;;uBAtJiC;8BACvB;yBAEN;AAUb,SAASL,eAAeM,aAAsB;IACnD,IAAIC;IACJ,IAAID,yBAAyBE,OAAO;QAClCD,iBAAiBD;IACnB,OAAO,IAAI,OAAOA,kBAAkB,UAAU;QAC5CC,iBAAiB,IAAIC,MAAMF;QAC3B,qCAAqC;QACrC,OAAOC,eAAeE,KAAK;IAC7B;IACA,OAAOF;AACT;AAYO,eAAeN,aACpBS,eAA8B,EAC9BC,WAAqC;IAErC,MAAMC,aAAaD,YAAYE,YAAY;IAC3C,OAAO,IAAIC,QAAc,CAACC,SAASC;QACjCN,gBACGO,IAAI,CAAC,CAACC;YACL,IAAIP,YAAYE,YAAY,KAAKD,YAAY;gBAC3CG,QAAQG;YACV,OAAO;gBACLC,IAAAA,YAAG,EACD;YAEJ;QACF,GACCC,KAAK,CAAC,CAACC;YACN,IAAIV,YAAYE,YAAY,KAAKD,YAAY;gBAC3CI,OAAOK;YACT,OAAO;gBACLF,IAAAA,YAAG,EACD;YAEJ;QACF;IACJ;AACF;AAUO,SAASjB,oBACdoB,QAAwB,EACxBC,OAAgB;IAEhB,qEAAqE;IACrE,sDAAsD;IACtD,MAAMC,QAAQ,IAAIC,MAChB,CAAC,GACD;QACEC,KAAIC,OAAe,EAAEC,IAAqB;YACxC,OACE,OAAOA,SAAS,YAChB;gBAAC;gBAAW;gBAAM;aAAiB,CAACC,QAAQ,CAACD;QAEjD;QACAE,KAAIH,OAAO,EAAEC,IAA0B;YACrC,IAAIA,SAAS,WAAW;gBACtB,OAAOL;YACT,OAAO,IAAI;gBAAC;gBAAM;aAAiB,CAACM,QAAQ,CAACD,OAAO;gBAClD,OAAON,QAAQ,CAACM,KAAK;YACvB;YAEA,OAAOG;QACT;IACF;IAGF,OAAOP;AACT;AAGO,MAAMrB,sBAAsB6B,OAAOC,MAAM,CAAC;IAC/C;IACA;IACA,6FAA6F;IAC7F;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAOM,SAAS7B,0BAA0B8B,IAAsB;IAC9D,4EAA4E;IAC5EC,IAAAA,aAAM,EACJC,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACL,KAAKM,MAAM,EAAE,cAC5CJ,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACL,KAAKM,MAAM,EAAE,UAChD;IAEFL,IAAAA,aAAM,EACJ,CAAChC,oBAAoB0B,QAAQ,CAACK,KAAKM,MAAM,GACzCC,uBAAS,CAACC,GAAG,CAACC,cAAc,CAAC;QAC3BC,MAAM;YACJJ,QAAQN,KAAKM,MAAM;QACrB;IACF;IAEFK,IAAAA,mBAAY,EAACX,MAAMY,iBAAU,EAAE;AACjC;AAOO,SAASzC,8BAA8B6B,IAAsB;IAClE,qDAAqD;IACrDC,IAAAA,aAAM,EACJ,CAACC,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACL,KAAKM,MAAM,EAAE,UAC/CC,uBAAS,CAACC,GAAG,CAACC,cAAc,CAAC;QAC3BC,MAAM;YACJJ,QAAQN,KAAKM,MAAM;QACrB;IACF;IAEFL,IAAAA,aAAM,EACJ,CAAChC,oBAAoB0B,QAAQ,CAACK,KAAKM,MAAM,GACzCC,uBAAS,CAACC,GAAG,CAACC,cAAc,CAAC;QAC3BC,MAAM;YACJJ,QAAQN,KAAKM,MAAM;QACrB;IACF;IAEFK,IAAAA,mBAAY,EAACX,MAAMY,iBAAU,EAAE;AACjC"}

package/dist/cjs/common/validation.js

@@ -0,0 +1,118 @@
+"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, {
+    JsonRpcRequestWithoutIdStruct: function() {
+        return JsonRpcRequestWithoutIdStruct;
+    },
+    EndowmentStruct: function() {
+        return EndowmentStruct;
+    },
+    isEndowment: function() {
+        return isEndowment;
+    },
+    isEndowmentsArray: function() {
+        return isEndowmentsArray;
+    },
+    PingRequestArgumentsStruct: function() {
+        return PingRequestArgumentsStruct;
+    },
+    TerminateRequestArgumentsStruct: function() {
+        return TerminateRequestArgumentsStruct;
+    },
+    ExecuteSnapRequestArgumentsStruct: function() {
+        return ExecuteSnapRequestArgumentsStruct;
+    },
+    SnapRpcRequestArgumentsStruct: function() {
+        return SnapRpcRequestArgumentsStruct;
+    },
+    OnTransactionRequestArgumentsStruct: function() {
+        return OnTransactionRequestArgumentsStruct;
+    },
+    assertIsOnTransactionRequestArguments: function() {
+        return assertIsOnTransactionRequestArguments;
+    },
+    OnNameLookupRequestArgumentsStruct: function() {
+        return OnNameLookupRequestArgumentsStruct;
+    },
+    assertIsOnNameLookupRequestArguments: function() {
+        return assertIsOnNameLookupRequestArguments;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _superstruct = require("superstruct");
+const JsonRpcRequestWithoutIdStruct = (0, _superstruct.assign)((0, _superstruct.omit)(_utils.JsonRpcRequestStruct, [
+    'id'
+]), (0, _superstruct.object)({
+    id: (0, _superstruct.optional)(_utils.JsonRpcIdStruct)
+}));
+const EndowmentStruct = (0, _superstruct.string)();
+function isEndowment(value) {
+    return (0, _superstruct.is)(value, EndowmentStruct);
+}
+function isEndowmentsArray(value) {
+    return Array.isArray(value) && value.every(isEndowment);
+}
+const OkStruct = (0, _superstruct.literal)('OK');
+const PingRequestArgumentsStruct = (0, _superstruct.optional)((0, _superstruct.union)([
+    (0, _superstruct.literal)(undefined),
+    (0, _superstruct.array)()
+]));
+const TerminateRequestArgumentsStruct = (0, _superstruct.union)([
+    (0, _superstruct.literal)(undefined),
+    (0, _superstruct.array)()
+]);
+const ExecuteSnapRequestArgumentsStruct = (0, _superstruct.tuple)([
+    (0, _superstruct.string)(),
+    (0, _superstruct.string)(),
+    (0, _superstruct.optional)((0, _superstruct.array)(EndowmentStruct))
+]);
+const SnapRpcRequestArgumentsStruct = (0, _superstruct.tuple)([
+    (0, _superstruct.string)(),
+    (0, _superstruct.enums)(Object.values(_snapsutils.HandlerType)),
+    (0, _superstruct.string)(),
+    (0, _superstruct.assign)(JsonRpcRequestWithoutIdStruct, (0, _superstruct.object)({
+        params: (0, _superstruct.optional)((0, _superstruct.record)((0, _superstruct.string)(), _utils.JsonStruct))
+    }))
+]);
+const OnTransactionRequestArgumentsStruct = (0, _superstruct.object)({
+    // TODO: Improve `transaction` type.
+    transaction: (0, _superstruct.record)((0, _superstruct.string)(), _utils.JsonStruct),
+    chainId: _snapsutils.ChainIdStruct,
+    transactionOrigin: (0, _superstruct.nullable)((0, _superstruct.string)())
+});
+function assertIsOnTransactionRequestArguments(value) {
+    (0, _utils.assertStruct)(value, OnTransactionRequestArgumentsStruct, 'Invalid request params');
+}
+const baseNameLookupArgs = {
+    chainId: _snapsutils.ChainIdStruct
+};
+const domainRequestStruct = (0, _superstruct.object)({
+    ...baseNameLookupArgs,
+    address: (0, _superstruct.string)()
+});
+const addressRequestStruct = (0, _superstruct.object)({
+    ...baseNameLookupArgs,
+    domain: (0, _superstruct.string)()
+});
+const OnNameLookupRequestArgumentsStruct = (0, _superstruct.union)([
+    domainRequestStruct,
+    addressRequestStruct
+]);
+function assertIsOnNameLookupRequestArguments(value) {
+    (0, _utils.assertStruct)(value, OnNameLookupRequestArgumentsStruct, 'Invalid request params');
+}
+const OkResponseStruct = (0, _superstruct.assign)(_utils.JsonRpcSuccessStruct, (0, _superstruct.object)({
+    result: OkStruct
+}));
+const SnapRpcResponse = _utils.JsonRpcSuccessStruct;
+
+//# sourceMappingURL=validation.js.map

package/dist/cjs/common/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/common/validation.ts"],"sourcesContent":["import { ChainIdStruct, HandlerType } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcSuccess } from '@metamask/utils';\nimport {\n  assertStruct,\n  JsonRpcIdStruct,\n  JsonRpcRequestStruct,\n  JsonRpcSuccessStruct,\n  JsonStruct,\n} from '@metamask/utils';\nimport type { Infer } from 'superstruct';\nimport {\n  array,\n  assign,\n  enums,\n  is,\n  literal,\n  nullable,\n  object,\n  omit,\n  optional,\n  record,\n  string,\n  tuple,\n  union,\n} from 'superstruct';\n\nexport const JsonRpcRequestWithoutIdStruct = assign(\n  omit(JsonRpcRequestStruct, ['id']),\n  object({\n    id: optional(JsonRpcIdStruct),\n  }),\n);\n\nexport type JsonRpcRequestWithoutId = Infer<\n  typeof JsonRpcRequestWithoutIdStruct\n>;\n\nexport const EndowmentStruct = string();\nexport type Endowment = Infer<typeof EndowmentStruct>;\n\n/**\n * Check if the given value is an endowment.\n *\n * @param value - The value to check.\n * @returns Whether the value is an endowment.\n */\nexport function isEndowment(value: unknown): value is Endowment {\n  return is(value, EndowmentStruct);\n}\n\n/**\n * Check if the given value is an array of endowments.\n *\n * @param value - The value to check.\n * @returns Whether the value is an array of endowments.\n */\nexport function isEndowmentsArray(value: unknown): value is Endowment[] {\n  return Array.isArray(value) && value.every(isEndowment);\n}\n\nconst OkStruct = literal('OK');\n\nexport const PingRequestArgumentsStruct = optional(\n  union([literal(undefined), array()]),\n);\n\nexport const TerminateRequestArgumentsStruct = union([\n  literal(undefined),\n  array(),\n]);\n\nexport const ExecuteSnapRequestArgumentsStruct = tuple([\n  string(),\n  string(),\n  optional(array(EndowmentStruct)),\n]);\n\nexport const SnapRpcRequestArgumentsStruct = tuple([\n  string(),\n  enums(Object.values(HandlerType)),\n  string(),\n  assign(\n    JsonRpcRequestWithoutIdStruct,\n    object({\n      params: optional(record(string(), JsonStruct)),\n    }),\n  ),\n]);\n\nexport type PingRequestArguments = Infer<typeof PingRequestArgumentsStruct>;\nexport type TerminateRequestArguments = Infer<\n  typeof TerminateRequestArgumentsStruct\n>;\n\nexport type ExecuteSnapRequestArguments = Infer<\n  typeof ExecuteSnapRequestArgumentsStruct\n>;\n\nexport type SnapRpcRequestArguments = Infer<\n  typeof SnapRpcRequestArgumentsStruct\n>;\n\nexport type RequestArguments =\n  | PingRequestArguments\n  | TerminateRequestArguments\n  | ExecuteSnapRequestArguments\n  | SnapRpcRequestArguments;\n\nexport const OnTransactionRequestArgumentsStruct = object({\n  // TODO: Improve `transaction` type.\n  transaction: record(string(), JsonStruct),\n  chainId: ChainIdStruct,\n  transactionOrigin: nullable(string()),\n});\n\nexport type OnTransactionRequestArguments = Infer<\n  typeof OnTransactionRequestArgumentsStruct\n>;\n\n/**\n * Asserts that the given value is a valid {@link OnTransactionRequestArguments}\n * object.\n *\n * @param value - The value to validate.\n * @throws If the value is not a valid {@link OnTransactionRequestArguments}\n * object.\n */\nexport function assertIsOnTransactionRequestArguments(\n  value: unknown,\n): asserts value is OnTransactionRequestArguments {\n  assertStruct(\n    value,\n    OnTransactionRequestArgumentsStruct,\n    'Invalid request params',\n  );\n}\n\nconst baseNameLookupArgs = { chainId: ChainIdStruct };\nconst domainRequestStruct = object({\n  ...baseNameLookupArgs,\n  address: string(),\n});\nconst addressRequestStruct = object({\n  ...baseNameLookupArgs,\n  domain: string(),\n});\n\nexport const OnNameLookupRequestArgumentsStruct = union([\n  domainRequestStruct,\n  addressRequestStruct,\n]);\n\nexport type OnNameLookupRequestArguments = Infer<\n  typeof OnNameLookupRequestArgumentsStruct\n>;\n\nexport type PossibleLookupRequestArgs = typeof baseNameLookupArgs & {\n  address?: string;\n  domain?: string;\n};\n\n/**\n * Asserts that the given value is a valid {@link OnNameLookupRequestArguments}\n * object.\n *\n * @param value - The value to validate.\n * @throws If the value is not a valid {@link OnNameLookupRequestArguments}\n * object.\n */\nexport function assertIsOnNameLookupRequestArguments(\n  value: unknown,\n): asserts value is OnNameLookupRequestArguments {\n  assertStruct(\n    value,\n    OnNameLookupRequestArgumentsStruct,\n    'Invalid request params',\n  );\n}\n\nconst OkResponseStruct = assign(\n  JsonRpcSuccessStruct,\n  object({\n    result: OkStruct,\n  }),\n);\n\nconst SnapRpcResponse = JsonRpcSuccessStruct;\n\nexport type OkResponse = Infer<typeof OkResponseStruct>;\nexport type SnapRpcResponse = Infer<typeof SnapRpcResponse>;\n\nexport type Response = OkResponse | SnapRpcResponse;\n\ntype RequestParams<Params extends unknown[] | undefined> =\n  Params extends undefined ? [] : Params;\n\ntype RequestFunction<\n  Args extends RequestArguments,\n  ResponseType extends JsonRpcSuccess<Json>,\n> = (...args: RequestParams<Args>) => Promise<ResponseType['result']>;\n\nexport type Ping = RequestFunction<PingRequestArguments, OkResponse>;\nexport type Terminate = RequestFunction<TerminateRequestArguments, OkResponse>;\nexport type ExecuteSnap = RequestFunction<\n  ExecuteSnapRequestArguments,\n  OkResponse\n>;\nexport type SnapRpc = RequestFunction<SnapRpcRequestArguments, SnapRpcResponse>;\n"],"names":["JsonRpcRequestWithoutIdStruct","EndowmentStruct","isEndowment","isEndowmentsArray","PingRequestArgumentsStruct","TerminateRequestArgumentsStruct","ExecuteSnapRequestArgumentsStruct","SnapRpcRequestArgumentsStruct","OnTransactionRequestArgumentsStruct","assertIsOnTransactionRequestArguments","OnNameLookupRequestArgumentsStruct","assertIsOnNameLookupRequestArguments","assign","omit","JsonRpcRequestStruct","object","id","optional","JsonRpcIdStruct","string","value","is","Array","isArray","every","OkStruct","literal","union","undefined","array","tuple","enums","Object","values","HandlerType","params","record","JsonStruct","transaction","chainId","ChainIdStruct","transactionOrigin","nullable","assertStruct","baseNameLookupArgs","domainRequestStruct","address","addressRequestStruct","domain","OkResponseStruct","JsonRpcSuccessStruct","result","SnapRpcResponse"],"mappings":";;;;;;;;;;;IA0BaA,6BAA6B;eAA7BA;;IAWAC,eAAe;eAAfA;;IASGC,WAAW;eAAXA;;IAUAC,iBAAiB;eAAjBA;;IAMHC,0BAA0B;eAA1BA;;IAIAC,+BAA+B;eAA/BA;;IAKAC,iCAAiC;eAAjCA;;IAMAC,6BAA6B;eAA7BA;;IA+BAC,mCAAmC;eAAnCA;;IAmBGC,qCAAqC;eAArCA;;IAoBHC,kCAAkC;eAAlCA;;IAsBGC,oCAAoC;eAApCA;;;4BAzK2B;uBAQpC;6BAgBA;AAEA,MAAMX,gCAAgCY,IAAAA,mBAAM,EACjDC,IAAAA,iBAAI,EAACC,2BAAoB,EAAE;IAAC;CAAK,GACjCC,IAAAA,mBAAM,EAAC;IACLC,IAAIC,IAAAA,qBAAQ,EAACC,sBAAe;AAC9B;AAOK,MAAMjB,kBAAkBkB,IAAAA,mBAAM;AAS9B,SAASjB,YAAYkB,KAAc;IACxC,OAAOC,IAAAA,eAAE,EAACD,OAAOnB;AACnB;AAQO,SAASE,kBAAkBiB,KAAc;IAC9C,OAAOE,MAAMC,OAAO,CAACH,UAAUA,MAAMI,KAAK,CAACtB;AAC7C;AAEA,MAAMuB,WAAWC,IAAAA,oBAAO,EAAC;AAElB,MAAMtB,6BAA6Ba,IAAAA,qBAAQ,EAChDU,IAAAA,kBAAK,EAAC;IAACD,IAAAA,oBAAO,EAACE;IAAYC,IAAAA,kBAAK;CAAG;AAG9B,MAAMxB,kCAAkCsB,IAAAA,kBAAK,EAAC;IACnDD,IAAAA,oBAAO,EAACE;IACRC,IAAAA,kBAAK;CACN;AAEM,MAAMvB,oCAAoCwB,IAAAA,kBAAK,EAAC;IACrDX,IAAAA,mBAAM;IACNA,IAAAA,mBAAM;IACNF,IAAAA,qBAAQ,EAACY,IAAAA,kBAAK,EAAC5B;CAChB;AAEM,MAAMM,gCAAgCuB,IAAAA,kBAAK,EAAC;IACjDX,IAAAA,mBAAM;IACNY,IAAAA,kBAAK,EAACC,OAAOC,MAAM,CAACC,uBAAW;IAC/Bf,IAAAA,mBAAM;IACNP,IAAAA,mBAAM,EACJZ,+BACAe,IAAAA,mBAAM,EAAC;QACLoB,QAAQlB,IAAAA,qBAAQ,EAACmB,IAAAA,mBAAM,EAACjB,IAAAA,mBAAM,KAAIkB,iBAAU;IAC9C;CAEH;AAqBM,MAAM7B,sCAAsCO,IAAAA,mBAAM,EAAC;IACxD,oCAAoC;IACpCuB,aAAaF,IAAAA,mBAAM,EAACjB,IAAAA,mBAAM,KAAIkB,iBAAU;IACxCE,SAASC,yBAAa;IACtBC,mBAAmBC,IAAAA,qBAAQ,EAACvB,IAAAA,mBAAM;AACpC;AAcO,SAASV,sCACdW,KAAc;IAEduB,IAAAA,mBAAY,EACVvB,OACAZ,qCACA;AAEJ;AAEA,MAAMoC,qBAAqB;IAAEL,SAASC,yBAAa;AAAC;AACpD,MAAMK,sBAAsB9B,IAAAA,mBAAM,EAAC;IACjC,GAAG6B,kBAAkB;IACrBE,SAAS3B,IAAAA,mBAAM;AACjB;AACA,MAAM4B,uBAAuBhC,IAAAA,mBAAM,EAAC;IAClC,GAAG6B,kBAAkB;IACrBI,QAAQ7B,IAAAA,mBAAM;AAChB;AAEO,MAAMT,qCAAqCiB,IAAAA,kBAAK,EAAC;IACtDkB;IACAE;CACD;AAmBM,SAASpC,qCACdS,KAAc;IAEduB,IAAAA,mBAAY,EACVvB,OACAV,oCACA;AAEJ;AAEA,MAAMuC,mBAAmBrC,IAAAA,mBAAM,EAC7BsC,2BAAoB,EACpBnC,IAAAA,mBAAM,EAAC;IACLoC,QAAQ1B;AACV;AAGF,MAAM2B,kBAAkBF,2BAAoB"}

package/dist/cjs/iframe/IFrameSnapExecutor.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IFrameSnapExecutor", {
+    enumerable: true,
+    get: function() {
+        return IFrameSnapExecutor;
+    }
+});
+const _objectmultiplex = /*#__PURE__*/ _interop_require_default(require("@metamask/object-multiplex"));
+const _postmessagestream = require("@metamask/post-message-stream");
+const _snapsutils = require("@metamask/snaps-utils");
+const _stream = require("stream");
+const _BaseSnapExecutor = require("../common/BaseSnapExecutor");
+const _logging = require("../logging");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class IFrameSnapExecutor extends _BaseSnapExecutor.BaseSnapExecutor {
+    /**
+   * Initialize the IFrameSnapExecutor. This creates a post message stream from
+   * and to the parent window, for two-way communication with the iframe.
+   *
+   * @param stream - The stream to use for communication.
+   * @returns An instance of `IFrameSnapExecutor`, with the initialized post
+   * message streams.
+   */ static initialize(stream = new _postmessagestream.WindowPostMessageStream({
+        name: 'child',
+        target: 'parent',
+        targetWindow: self.parent,
+        targetOrigin: '*'
+    })) {
+        (0, _logging.log)('Worker: Connecting to parent.');
+        const mux = new _objectmultiplex.default();
+        (0, _stream.pipeline)(stream, mux, stream, (error)=>{
+            if (error) {
+                (0, _snapsutils.logError)(`Parent stream failure, closing worker.`, error);
+            }
+            self.close();
+        });
+        const commandStream = mux.createStream(_snapsutils.SNAP_STREAM_NAMES.COMMAND);
+        const rpcStream = mux.createStream(_snapsutils.SNAP_STREAM_NAMES.JSON_RPC);
+        return new IFrameSnapExecutor(commandStream, rpcStream);
+    }
+}
+
+//# sourceMappingURL=IFrameSnapExecutor.js.map

package/dist/cjs/iframe/IFrameSnapExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/iframe/IFrameSnapExecutor.ts"],"sourcesContent":["import ObjectMultiplex from '@metamask/object-multiplex';\nimport type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { WindowPostMessageStream } from '@metamask/post-message-stream';\nimport { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';\nimport { pipeline } from 'stream';\n\nimport { BaseSnapExecutor } from '../common/BaseSnapExecutor';\nimport { log } from '../logging';\n\nexport class IFrameSnapExecutor extends BaseSnapExecutor {\n  /**\n   * Initialize the IFrameSnapExecutor. This creates a post message stream from\n   * and to the parent window, for two-way communication with the iframe.\n   *\n   * @param stream - The stream to use for communication.\n   * @returns An instance of `IFrameSnapExecutor`, with the initialized post\n   * message streams.\n   */\n  static initialize(\n    stream: BasePostMessageStream = new WindowPostMessageStream({\n      name: 'child',\n      target: 'parent',\n      targetWindow: self.parent,\n      targetOrigin: '*',\n    }),\n  ) {\n    log('Worker: Connecting to parent.');\n\n    const mux = new ObjectMultiplex();\n    pipeline(stream, mux, stream, (error) => {\n      if (error) {\n        logError(`Parent stream failure, closing worker.`, error);\n      }\n      self.close();\n    });\n\n    const commandStream = mux.createStream(SNAP_STREAM_NAMES.COMMAND);\n    const rpcStream = mux.createStream(SNAP_STREAM_NAMES.JSON_RPC);\n\n    return new IFrameSnapExecutor(commandStream, rpcStream);\n  }\n}\n"],"names":["IFrameSnapExecutor","BaseSnapExecutor","initialize","stream","WindowPostMessageStream","name","target","targetWindow","self","parent","targetOrigin","log","mux","ObjectMultiplex","pipeline","error","logError","close","commandStream","createStream","SNAP_STREAM_NAMES","COMMAND","rpcStream","JSON_RPC"],"mappings":";;;;+BASaA;;;eAAAA;;;wEATe;mCAEY;4BACI;wBACnB;kCAEQ;yBACb;;;;;;AAEb,MAAMA,2BAA2BC,kCAAgB;IACtD;;;;;;;GAOC,GACD,OAAOC,WACLC,SAAgC,IAAIC,0CAAuB,CAAC;QAC1DC,MAAM;QACNC,QAAQ;QACRC,cAAcC,KAAKC,MAAM;QACzBC,cAAc;IAChB,EAAE,EACF;QACAC,IAAAA,YAAG,EAAC;QAEJ,MAAMC,MAAM,IAAIC,wBAAe;QAC/BC,IAAAA,gBAAQ,EAACX,QAAQS,KAAKT,QAAQ,CAACY;YAC7B,IAAIA,OAAO;gBACTC,IAAAA,oBAAQ,EAAC,CAAC,sCAAsC,CAAC,EAAED;YACrD;YACAP,KAAKS,KAAK;QACZ;QAEA,MAAMC,gBAAgBN,IAAIO,YAAY,CAACC,6BAAiB,CAACC,OAAO;QAChE,MAAMC,YAAYV,IAAIO,YAAY,CAACC,6BAAiB,CAACG,QAAQ;QAE7D,OAAO,IAAIvB,mBAAmBkB,eAAeI;IAC/C;AACF"}

package/dist/cjs/iframe/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _lockdownevents = require("../common/lockdown/lockdown-events");
+const _lockdownmore = require("../common/lockdown/lockdown-more");
+const _IFrameSnapExecutor = require("./IFrameSnapExecutor");
+// Lockdown is already applied in LavaMoat
+(0, _lockdownmore.executeLockdownMore)();
+(0, _lockdownevents.executeLockdownEvents)();
+_IFrameSnapExecutor.IFrameSnapExecutor.initialize();
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/iframe/index.ts"],"sourcesContent":["import { executeLockdownEvents } from '../common/lockdown/lockdown-events';\nimport { executeLockdownMore } from '../common/lockdown/lockdown-more';\nimport { IFrameSnapExecutor } from './IFrameSnapExecutor';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\nexecuteLockdownEvents();\n\nIFrameSnapExecutor.initialize();\n"],"names":["executeLockdownMore","executeLockdownEvents","IFrameSnapExecutor","initialize"],"mappings":";;;;gCAAsC;8BACF;oCACD;AAEnC,0CAA0C;AAC1CA,IAAAA,iCAAmB;AACnBC,IAAAA,qCAAqB;AAErBC,sCAAkB,CAACC,UAAU"}

package/dist/cjs/logging.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "log", {
+    enumerable: true,
+    get: function() {
+        return log;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const log = (0, _utils.createModuleLogger)(_snapsutils.snapsLogger, 'snaps-execution-environments');
+
+//# sourceMappingURL=logging.js.map

package/dist/cjs/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging.ts"],"sourcesContent":["import { snapsLogger } from '@metamask/snaps-utils';\nimport { createModuleLogger } from '@metamask/utils';\n\n/**\n * A logging function specific to this package. The log messages don't show up\n * by default, but they can be enabled by setting the environment variable:\n * - `DEBUG=metamask:snaps:snaps-execution-environments`, or\n * - `DEBUG=metamask:snaps:*` to enable all logs from `@metamask/snaps-*`.\n */\nexport const log = createModuleLogger(\n  snapsLogger,\n  'snaps-execution-environments',\n);\n"],"names":["log","createModuleLogger","snapsLogger"],"mappings":";;;;+BASaA;;;eAAAA;;;4BATe;uBACO;AAQ5B,MAAMA,MAAMC,IAAAA,yBAAkB,EACnCC,uBAAW,EACX"}

package/dist/cjs/node-process/ChildProcessSnapExecutor.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ChildProcessSnapExecutor", {
+    enumerable: true,
+    get: function() {
+        return ChildProcessSnapExecutor;
+    }
+});
+const _objectmultiplex = /*#__PURE__*/ _interop_require_default(require("@metamask/object-multiplex"));
+const _postmessagestream = require("@metamask/post-message-stream");
+const _snapsutils = require("@metamask/snaps-utils");
+const _stream = require("stream");
+const _BaseSnapExecutor = require("../common/BaseSnapExecutor");
+const _logging = require("../logging");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class ChildProcessSnapExecutor extends _BaseSnapExecutor.BaseSnapExecutor {
+    static initialize() {
+        (0, _logging.log)('Worker: Connecting to parent.');
+        const parentStream = new _postmessagestream.ProcessMessageStream();
+        const mux = new _objectmultiplex.default();
+        (0, _stream.pipeline)(parentStream, mux, parentStream, (error)=>{
+            if (error) {
+                (0, _snapsutils.logError)(`Parent stream failure, closing worker.`, error);
+            }
+            self.close();
+        });
+        const commandStream = mux.createStream(_snapsutils.SNAP_STREAM_NAMES.COMMAND);
+        const rpcStream = mux.createStream(_snapsutils.SNAP_STREAM_NAMES.JSON_RPC);
+        return new ChildProcessSnapExecutor(commandStream, rpcStream);
+    }
+}
+
+//# sourceMappingURL=ChildProcessSnapExecutor.js.map

package/dist/cjs/node-process/ChildProcessSnapExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/node-process/ChildProcessSnapExecutor.ts"],"sourcesContent":["import ObjectMultiplex from '@metamask/object-multiplex';\nimport { ProcessMessageStream } from '@metamask/post-message-stream';\nimport { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';\nimport { pipeline } from 'stream';\n\nimport { BaseSnapExecutor } from '../common/BaseSnapExecutor';\nimport { log } from '../logging';\n\nexport class ChildProcessSnapExecutor extends BaseSnapExecutor {\n  static initialize() {\n    log('Worker: Connecting to parent.');\n\n    const parentStream = new ProcessMessageStream();\n    const mux = new ObjectMultiplex();\n    pipeline(parentStream, mux as any, parentStream, (error) => {\n      if (error) {\n        logError(`Parent stream failure, closing worker.`, error);\n      }\n      self.close();\n    });\n\n    const commandStream = mux.createStream(SNAP_STREAM_NAMES.COMMAND);\n    const rpcStream = mux.createStream(SNAP_STREAM_NAMES.JSON_RPC) as any;\n    return new ChildProcessSnapExecutor(commandStream, rpcStream);\n  }\n}\n"],"names":["ChildProcessSnapExecutor","BaseSnapExecutor","initialize","log","parentStream","ProcessMessageStream","mux","ObjectMultiplex","pipeline","error","logError","self","close","commandStream","createStream","SNAP_STREAM_NAMES","COMMAND","rpcStream","JSON_RPC"],"mappings":";;;;+BAQaA;;;eAAAA;;;wEARe;mCACS;4BACO;wBACnB;kCAEQ;yBACb;;;;;;AAEb,MAAMA,iCAAiCC,kCAAgB;IAC5D,OAAOC,aAAa;QAClBC,IAAAA,YAAG,EAAC;QAEJ,MAAMC,eAAe,IAAIC,uCAAoB;QAC7C,MAAMC,MAAM,IAAIC,wBAAe;QAC/BC,IAAAA,gBAAQ,EAACJ,cAAcE,KAAYF,cAAc,CAACK;YAChD,IAAIA,OAAO;gBACTC,IAAAA,oBAAQ,EAAC,CAAC,sCAAsC,CAAC,EAAED;YACrD;YACAE,KAAKC,KAAK;QACZ;QAEA,MAAMC,gBAAgBP,IAAIQ,YAAY,CAACC,6BAAiB,CAACC,OAAO;QAChE,MAAMC,YAAYX,IAAIQ,YAAY,CAACC,6BAAiB,CAACG,QAAQ;QAC7D,OAAO,IAAIlB,yBAAyBa,eAAeI;IACrD;AACF"}

package/dist/cjs/node-process/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _lockdownmore = require("../common/lockdown/lockdown-more");
+const _ChildProcessSnapExecutor = require("./ChildProcessSnapExecutor");
+// Lockdown is already applied in LavaMoat
+(0, _lockdownmore.executeLockdownMore)();
+_ChildProcessSnapExecutor.ChildProcessSnapExecutor.initialize();
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/node-process/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/node-process/index.ts"],"sourcesContent":["import { executeLockdownMore } from '../common/lockdown/lockdown-more';\nimport { ChildProcessSnapExecutor } from './ChildProcessSnapExecutor';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\n\nChildProcessSnapExecutor.initialize();\n"],"names":["executeLockdownMore","ChildProcessSnapExecutor","initialize"],"mappings":";;;;8BAAoC;0CACK;AAEzC,0CAA0C;AAC1CA,IAAAA,iCAAmB;AAEnBC,kDAAwB,CAACC,UAAU"}