@metamask/snaps-execution-environments 4.0.1 → 5.0.0

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

@@ -1,82 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment
-/// <reference path="../../../../../node_modules/ses/types.d.ts" />
-import { logError } from '@metamask/snaps-utils';
-/**
- * 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 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) {
-        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/esm/common/lockdown/lockdown-more.js.map

@@ -1 +0,0 @@
-{"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":["logError","executeLockdownMore","namedIntrinsics","Reflect","ownKeys","Compartment","globalThis","shouldHardenManually","Set","globalProperties","forEach","propertyName","descriptor","getOwnPropertyDescriptor","configurable","hasAccessor","Object","defineProperty","writable","has","harden","error"],"mappings":"AAAA,qFAAqF;AACrF,mEAAmE;AAEnE,SAASA,QAAQ,QAAQ,wBAAwB;AAEjD;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,SAASC;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;QACdrB,SAAS,iCAAiCqB;QAC1C,MAAMA;IACR;AACF;AAEA;;;;;;;;;CASC,GACD,SAASN,YAAYH,UAAe;IAClC,OAAO,SAASA,cAAc,SAASA;AACzC"}

package/dist/esm/common/lockdown/lockdown.js

@@ -1,24 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment
-/// <reference path="../../../../../node_modules/ses/types.d.ts" />
-import { logError } from '@metamask/snaps-utils';
-/**
- * Execute SES lockdown in the current context, i.e., the current iframe.
- *
- * @throws If the SES lockdown failed.
- */ export 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
-        logError('Lockdown failed:', error);
-        throw error;
-    }
-}
-
-//# sourceMappingURL=lockdown.js.map

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

@@ -1 +0,0 @@
-{"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":["logError","executeLockdown","lockdown","consoleTaming","errorTaming","mathTaming","dateTaming","overrideTaming","error"],"mappings":"AAAA,qFAAqF;AACrF,mEAAmE;AAEnE,SAASA,QAAQ,QAAQ,wBAAwB;AAEjD;;;;CAIC,GACD,OAAO,SAASC;IACd,IAAI;QACFC,SAAS;YACPC,eAAe;YACfC,aAAa;YACbC,YAAY;YACZC,YAAY;YACZC,gBAAgB;QAClB;IACF,EAAE,OAAOC,OAAO;QACd,gFAAgF;QAChFR,SAAS,oBAAoBQ;QAC7B,MAAMA;IACR;AACF"}

package/dist/esm/common/sortParams.js

@@ -1,29 +0,0 @@
-// original source sortParamKeys from: https://github.com/etclabscore/sig.tools/blob/master/src/postMessageServer/postMessageServer.ts#L75-L77
-/**
- * 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 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/esm/common/sortParams.js.map

@@ -1 +0,0 @@
-{"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;AAI9I;;;;;;;;;;;;;CAaC,GACD,OAAO,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,EAAE"}

package/dist/esm/common/utils.js

@@ -1,128 +0,0 @@
-import { rpcErrors } from '@metamask/rpc-errors';
-import { assert, assertStruct, getSafeJson, JsonStruct } from '@metamask/utils';
-import { log } from '../logging';
-/**
- * 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 async function withTeardown(originalPromise, teardownRef) {
-    const myTeardown = teardownRef.lastTeardown;
-    return new Promise((resolve, reject)=>{
-        originalPromise.then((value)=>{
-            if (teardownRef.lastTeardown === myTeardown) {
-                resolve(value);
-            } else {
-                log('Late promise received after Snap finished execution. Promise will be dropped.');
-            }
-        }).catch((reason)=>{
-            if (teardownRef.lastTeardown === myTeardown) {
-                reject(reason);
-            } else {
-                log('Late promise received after Snap finished execution. Promise will be dropped.');
-            }
-        });
-    });
-}
-/**
- * Returns a Proxy that narrows down (attenuates) the fields available on
- * the StreamProvider and replaces the request implementation.
- *
- * @param provider - Instance of a StreamProvider to be limited.
- * @param request - Custom attenuated request object.
- * @returns Proxy to the StreamProvider instance.
- */ export 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;
-}
-// We're blocking these RPC methods for v1, will revisit later.
-export const BLOCKED_RPC_METHODS = Object.freeze([
-    'wallet_requestSnaps',
-    'wallet_requestPermissions',
-    'wallet_revokePermissions',
-    // 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'
-]);
-/**
- * Asserts the validity of request arguments for a snap outbound request using the `snap.request` API.
- *
- * @param args - The arguments to validate.
- */ export function assertSnapOutboundRequest(args) {
-    // Disallow any non `wallet_` or `snap_` methods for separation of concerns.
-    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_*`.', rpcErrors.methodNotSupported);
-    assert(!BLOCKED_RPC_METHODS.includes(args.method), rpcErrors.methodNotFound({
-        data: {
-            method: args.method
-        }
-    }));
-    assertStruct(args, JsonStruct, 'Provided value is not JSON-RPC compatible', rpcErrors.invalidParams);
-}
-/**
- * Asserts the validity of request arguments for an ethereum outbound request using the `ethereum.request` API.
- *
- * @param args - The arguments to validate.
- */ export function assertEthereumOutboundRequest(args) {
-    // Disallow snaps methods for separation of concerns.
-    assert(!String.prototype.startsWith.call(args.method, 'snap_'), rpcErrors.methodNotFound({
-        data: {
-            method: args.method
-        }
-    }));
-    assert(!BLOCKED_RPC_METHODS.includes(args.method), rpcErrors.methodNotFound({
-        data: {
-            method: args.method
-        }
-    }));
-    assertStruct(args, JsonStruct, 'Provided value is not JSON-RPC compatible', rpcErrors.invalidParams);
-}
-/**
- * Gets a sanitized value to be used for passing to the underlying MetaMask provider.
- *
- * @param value - An unsanitized value from a snap.
- * @returns A sanitized value ready to be passed to a MetaMask provider.
- */ export function sanitizeRequestArguments(value) {
-    // Before passing to getSafeJson we run the value through JSON serialization.
-    // This lets request arguments contain undefined which is normally disallowed.
-    const json = JSON.parse(JSON.stringify(value));
-    return getSafeJson(json);
-}
-
-//# sourceMappingURL=utils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/common/utils.ts"],"sourcesContent":["import type { StreamProvider } from '@metamask/providers';\nimport type { RequestArguments } from '@metamask/providers/dist/BaseProvider';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { assert, assertStruct, getSafeJson, JsonStruct } from '@metamask/utils';\n\nimport { log } from '../logging';\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  'wallet_revokePermissions',\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    rpcErrors.methodNotSupported,\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(\n    args,\n    JsonStruct,\n    'Provided value is not JSON-RPC compatible',\n    rpcErrors.invalidParams,\n  );\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    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(\n    args,\n    JsonStruct,\n    'Provided value is not JSON-RPC compatible',\n    rpcErrors.invalidParams,\n  );\n}\n\n/**\n * Gets a sanitized value to be used for passing to the underlying MetaMask provider.\n *\n * @param value - An unsanitized value from a snap.\n * @returns A sanitized value ready to be passed to a MetaMask provider.\n */\nexport function sanitizeRequestArguments(value: unknown): RequestArguments {\n  // Before passing to getSafeJson we run the value through JSON serialization.\n  // This lets request arguments contain undefined which is normally disallowed.\n  const json = JSON.parse(JSON.stringify(value));\n  return getSafeJson(json) as RequestArguments;\n}\n"],"names":["rpcErrors","assert","assertStruct","getSafeJson","JsonStruct","log","withTeardown","originalPromise","teardownRef","myTeardown","lastTeardown","Promise","resolve","reject","then","value","catch","reason","proxyStreamProvider","provider","request","proxy","Proxy","has","_target","prop","includes","get","undefined","BLOCKED_RPC_METHODS","Object","freeze","assertSnapOutboundRequest","args","String","prototype","startsWith","call","method","methodNotSupported","methodNotFound","data","invalidParams","assertEthereumOutboundRequest","sanitizeRequestArguments","json","JSON","parse","stringify"],"mappings":"AAEA,SAASA,SAAS,QAAQ,uBAAuB;AACjD,SAASC,MAAM,EAAEC,YAAY,EAAEC,WAAW,EAAEC,UAAU,QAAQ,kBAAkB;AAEhF,SAASC,GAAG,QAAQ,aAAa;AACjC;;;;;;;;;CASC,GACD,OAAO,eAAeC,aACpBC,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;gBACLV,IACE;YAEJ;QACF,GACCW,KAAK,CAAC,CAACC;YACN,IAAIT,YAAYE,YAAY,KAAKD,YAAY;gBAC3CI,OAAOI;YACT,OAAO;gBACLZ,IACE;YAEJ;QACF;IACJ;AACF;AAEA;;;;;;;CAOC,GACD,OAAO,SAASa,oBACdC,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;AAEA,+DAA+D;AAC/D,OAAO,MAAMQ,sBAAsBC,OAAOC,MAAM,CAAC;IAC/C;IACA;IACA;IACA,6FAA6F;IAC7F;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD,EAAE;AAEH;;;;CAIC,GACD,OAAO,SAASC,0BAA0BC,IAAsB;IAC9D,4EAA4E;IAC5EhC,OACEiC,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACJ,KAAKK,MAAM,EAAE,cAC5CJ,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACJ,KAAKK,MAAM,EAAE,UAChD,sFACAtC,UAAUuC,kBAAkB;IAE9BtC,OACE,CAAC4B,oBAAoBH,QAAQ,CAACO,KAAKK,MAAM,GACzCtC,UAAUwC,cAAc,CAAC;QACvBC,MAAM;YACJH,QAAQL,KAAKK,MAAM;QACrB;IACF;IAEFpC,aACE+B,MACA7B,YACA,6CACAJ,UAAU0C,aAAa;AAE3B;AAEA;;;;CAIC,GACD,OAAO,SAASC,8BAA8BV,IAAsB;IAClE,qDAAqD;IACrDhC,OACE,CAACiC,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACJ,KAAKK,MAAM,EAAE,UAC/CtC,UAAUwC,cAAc,CAAC;QACvBC,MAAM;YACJH,QAAQL,KAAKK,MAAM;QACrB;IACF;IAEFrC,OACE,CAAC4B,oBAAoBH,QAAQ,CAACO,KAAKK,MAAM,GACzCtC,UAAUwC,cAAc,CAAC;QACvBC,MAAM;YACJH,QAAQL,KAAKK,MAAM;QACrB;IACF;IAEFpC,aACE+B,MACA7B,YACA,6CACAJ,UAAU0C,aAAa;AAE3B;AAEA;;;;;CAKC,GACD,OAAO,SAASE,yBAAyB7B,KAAc;IACrD,6EAA6E;IAC7E,8EAA8E;IAC9E,MAAM8B,OAAOC,KAAKC,KAAK,CAACD,KAAKE,SAAS,CAACjC;IACvC,OAAOZ,YAAY0C;AACrB"}

package/dist/esm/common/validation.js

@@ -1,127 +0,0 @@
-import { rpcErrors } from '@metamask/rpc-errors';
-import { UserInputEventStruct } from '@metamask/snaps-sdk';
-import { ChainIdStruct, HandlerType } from '@metamask/snaps-utils';
-import { assertStruct, JsonRpcIdStruct, JsonRpcParamsStruct, JsonRpcSuccessStruct, JsonRpcVersionStruct, JsonStruct } from '@metamask/utils';
-import { array, assign, enums, is, literal, nullable, object, optional, record, string, tuple, union } from 'superstruct';
-export const JsonRpcRequestWithoutIdStruct = object({
-    jsonrpc: optional(JsonRpcVersionStruct),
-    id: optional(JsonRpcIdStruct),
-    method: string(),
-    params: optional(JsonRpcParamsStruct)
-});
-export const EndowmentStruct = string();
-/**
- * Check if the given value is an endowment.
- *
- * @param value - The value to check.
- * @returns Whether the value is an endowment.
- */ export function isEndowment(value) {
-    return is(value, EndowmentStruct);
-}
-/**
- * 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 function isEndowmentsArray(value) {
-    return Array.isArray(value) && value.every(isEndowment);
-}
-const OkStruct = literal('OK');
-export const PingRequestArgumentsStruct = optional(union([
-    literal(undefined),
-    array()
-]));
-export const TerminateRequestArgumentsStruct = union([
-    literal(undefined),
-    array()
-]);
-export const ExecuteSnapRequestArgumentsStruct = tuple([
-    string(),
-    string(),
-    array(EndowmentStruct)
-]);
-export const SnapRpcRequestArgumentsStruct = tuple([
-    string(),
-    enums(Object.values(HandlerType)),
-    string(),
-    assign(JsonRpcRequestWithoutIdStruct, object({
-        params: optional(record(string(), JsonStruct))
-    }))
-]);
-export const OnTransactionRequestArgumentsStruct = object({
-    // TODO: Improve `transaction` type.
-    transaction: record(string(), JsonStruct),
-    chainId: ChainIdStruct,
-    transactionOrigin: nullable(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.
- */ export function assertIsOnTransactionRequestArguments(value) {
-    assertStruct(value, OnTransactionRequestArgumentsStruct, 'Invalid request params', rpcErrors.invalidParams);
-}
-export const OnSignatureRequestArgumentsStruct = object({
-    signature: record(string(), JsonStruct),
-    signatureOrigin: nullable(string())
-});
-/**
- * Asserts that the given value is a valid {@link OnSignatureRequestArguments}
- * object.
- *
- * @param value - The value to validate.
- * @throws If the value is not a valid {@link OnSignatureRequestArguments}
- * object.
- */ export function assertIsOnSignatureRequestArguments(value) {
-    assertStruct(value, OnSignatureRequestArgumentsStruct, 'Invalid request params', rpcErrors.invalidParams);
-}
-const baseNameLookupArgs = {
-    chainId: ChainIdStruct
-};
-const domainRequestStruct = object({
-    ...baseNameLookupArgs,
-    address: string()
-});
-const addressRequestStruct = object({
-    ...baseNameLookupArgs,
-    domain: string()
-});
-export const OnNameLookupRequestArgumentsStruct = union([
-    domainRequestStruct,
-    addressRequestStruct
-]);
-/**
- * Asserts that the given value is a valid {@link OnNameLookupRequestArguments}
- * object.
- *
- * @param value - The value to validate.
- * @throws If the value is not a valid {@link OnNameLookupRequestArguments}
- * object.
- */ export function assertIsOnNameLookupRequestArguments(value) {
-    assertStruct(value, OnNameLookupRequestArgumentsStruct, 'Invalid request params', rpcErrors.invalidParams);
-}
-export const OnUserInputArgumentsStruct = object({
-    id: string(),
-    event: UserInputEventStruct
-});
-/**
- * Asserts that the given value is a valid {@link OnUserInputArguments}
- * object.
- *
- * @param value - The value to validate.
- * @throws If the value is not a valid {@link OnUserInputArguments}
- * object.
- */ export function assertIsOnUserInputRequestArguments(value) {
-    assertStruct(value, OnUserInputArgumentsStruct, 'Invalid request params', rpcErrors.invalidParams);
-}
-const OkResponseStruct = object({
-    id: JsonRpcIdStruct,
-    jsonrpc: JsonRpcVersionStruct,
-    result: OkStruct
-});
-const SnapRpcResponse = JsonRpcSuccessStruct;
-
-//# sourceMappingURL=validation.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/common/validation.ts"],"sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\nimport { UserInputEventStruct } from '@metamask/snaps-sdk';\nimport { ChainIdStruct, HandlerType } from '@metamask/snaps-utils';\nimport type { Json, JsonRpcSuccess } from '@metamask/utils';\nimport {\n  assertStruct,\n  JsonRpcIdStruct,\n  JsonRpcParamsStruct,\n  JsonRpcSuccessStruct,\n  JsonRpcVersionStruct,\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  optional,\n  record,\n  string,\n  tuple,\n  union,\n} from 'superstruct';\n\nexport const JsonRpcRequestWithoutIdStruct = object({\n  jsonrpc: optional(JsonRpcVersionStruct),\n  id: optional(JsonRpcIdStruct),\n  method: string(),\n  params: optional(JsonRpcParamsStruct),\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  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    rpcErrors.invalidParams,\n  );\n}\n\nexport const OnSignatureRequestArgumentsStruct = object({\n  signature: record(string(), JsonStruct),\n  signatureOrigin: nullable(string()),\n});\n\nexport type OnSignatureRequestArguments = Infer<\n  typeof OnSignatureRequestArgumentsStruct\n>;\n\n/**\n * Asserts that the given value is a valid {@link OnSignatureRequestArguments}\n * object.\n *\n * @param value - The value to validate.\n * @throws If the value is not a valid {@link OnSignatureRequestArguments}\n * object.\n */\nexport function assertIsOnSignatureRequestArguments(\n  value: unknown,\n): asserts value is OnSignatureRequestArguments {\n  assertStruct(\n    value,\n    OnSignatureRequestArgumentsStruct,\n    'Invalid request params',\n    rpcErrors.invalidParams,\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    rpcErrors.invalidParams,\n  );\n}\n\nexport const OnUserInputArgumentsStruct = object({\n  id: string(),\n  event: UserInputEventStruct,\n});\n\nexport type OnUserInputArguments = Infer<typeof OnUserInputArgumentsStruct>;\n\n/**\n * Asserts that the given value is a valid {@link OnUserInputArguments}\n * object.\n *\n * @param value - The value to validate.\n * @throws If the value is not a valid {@link OnUserInputArguments}\n * object.\n */\nexport function assertIsOnUserInputRequestArguments(\n  value: unknown,\n): asserts value is OnUserInputArguments {\n  assertStruct(\n    value,\n    OnUserInputArgumentsStruct,\n    'Invalid request params',\n    rpcErrors.invalidParams,\n  );\n}\n\nconst OkResponseStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: OkStruct,\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":["rpcErrors","UserInputEventStruct","ChainIdStruct","HandlerType","assertStruct","JsonRpcIdStruct","JsonRpcParamsStruct","JsonRpcSuccessStruct","JsonRpcVersionStruct","JsonStruct","array","assign","enums","is","literal","nullable","object","optional","record","string","tuple","union","JsonRpcRequestWithoutIdStruct","jsonrpc","id","method","params","EndowmentStruct","isEndowment","value","isEndowmentsArray","Array","isArray","every","OkStruct","PingRequestArgumentsStruct","undefined","TerminateRequestArgumentsStruct","ExecuteSnapRequestArgumentsStruct","SnapRpcRequestArgumentsStruct","Object","values","OnTransactionRequestArgumentsStruct","transaction","chainId","transactionOrigin","assertIsOnTransactionRequestArguments","invalidParams","OnSignatureRequestArgumentsStruct","signature","signatureOrigin","assertIsOnSignatureRequestArguments","baseNameLookupArgs","domainRequestStruct","address","addressRequestStruct","domain","OnNameLookupRequestArgumentsStruct","assertIsOnNameLookupRequestArguments","OnUserInputArgumentsStruct","event","assertIsOnUserInputRequestArguments","OkResponseStruct","result","SnapRpcResponse"],"mappings":"AAAA,SAASA,SAAS,QAAQ,uBAAuB;AACjD,SAASC,oBAAoB,QAAQ,sBAAsB;AAC3D,SAASC,aAAa,EAAEC,WAAW,QAAQ,wBAAwB;AAEnE,SACEC,YAAY,EACZC,eAAe,EACfC,mBAAmB,EACnBC,oBAAoB,EACpBC,oBAAoB,EACpBC,UAAU,QACL,kBAAkB;AAEzB,SACEC,KAAK,EACLC,MAAM,EACNC,KAAK,EACLC,EAAE,EACFC,OAAO,EACPC,QAAQ,EACRC,MAAM,EACNC,QAAQ,EACRC,MAAM,EACNC,MAAM,EACNC,KAAK,EACLC,KAAK,QACA,cAAc;AAErB,OAAO,MAAMC,gCAAgCN,OAAO;IAClDO,SAASN,SAAST;IAClBgB,IAAIP,SAASZ;IACboB,QAAQN;IACRO,QAAQT,SAASX;AACnB,GAAG;AAMH,OAAO,MAAMqB,kBAAkBR,SAAS;AAGxC;;;;;CAKC,GACD,OAAO,SAASS,YAAYC,KAAc;IACxC,OAAOhB,GAAGgB,OAAOF;AACnB;AAEA;;;;;CAKC,GACD,OAAO,SAASG,kBAAkBD,KAAc;IAC9C,OAAOE,MAAMC,OAAO,CAACH,UAAUA,MAAMI,KAAK,CAACL;AAC7C;AAEA,MAAMM,WAAWpB,QAAQ;AAEzB,OAAO,MAAMqB,6BAA6BlB,SACxCI,MAAM;IAACP,QAAQsB;IAAY1B;CAAQ,GACnC;AAEF,OAAO,MAAM2B,kCAAkChB,MAAM;IACnDP,QAAQsB;IACR1B;CACD,EAAE;AAEH,OAAO,MAAM4B,oCAAoClB,MAAM;IACrDD;IACAA;IACAT,MAAMiB;CACP,EAAE;AAEH,OAAO,MAAMY,gCAAgCnB,MAAM;IACjDD;IACAP,MAAM4B,OAAOC,MAAM,CAACtC;IACpBgB;IACAR,OACEW,+BACAN,OAAO;QACLU,QAAQT,SAASC,OAAOC,UAAUV;IACpC;CAEH,EAAE;AAqBH,OAAO,MAAMiC,sCAAsC1B,OAAO;IACxD,oCAAoC;IACpC2B,aAAazB,OAAOC,UAAUV;IAC9BmC,SAAS1C;IACT2C,mBAAmB9B,SAASI;AAC9B,GAAG;AAMH;;;;;;;CAOC,GACD,OAAO,SAAS2B,sCACdjB,KAAc;IAEdzB,aACEyB,OACAa,qCACA,0BACA1C,UAAU+C,aAAa;AAE3B;AAEA,OAAO,MAAMC,oCAAoChC,OAAO;IACtDiC,WAAW/B,OAAOC,UAAUV;IAC5ByC,iBAAiBnC,SAASI;AAC5B,GAAG;AAMH;;;;;;;CAOC,GACD,OAAO,SAASgC,oCACdtB,KAAc;IAEdzB,aACEyB,OACAmB,mCACA,0BACAhD,UAAU+C,aAAa;AAE3B;AAEA,MAAMK,qBAAqB;IAAER,SAAS1C;AAAc;AACpD,MAAMmD,sBAAsBrC,OAAO;IACjC,GAAGoC,kBAAkB;IACrBE,SAASnC;AACX;AACA,MAAMoC,uBAAuBvC,OAAO;IAClC,GAAGoC,kBAAkB;IACrBI,QAAQrC;AACV;AAEA,OAAO,MAAMsC,qCAAqCpC,MAAM;IACtDgC;IACAE;CACD,EAAE;AAWH;;;;;;;CAOC,GACD,OAAO,SAASG,qCACd7B,KAAc;IAEdzB,aACEyB,OACA4B,oCACA,0BACAzD,UAAU+C,aAAa;AAE3B;AAEA,OAAO,MAAMY,6BAA6B3C,OAAO;IAC/CQ,IAAIL;IACJyC,OAAO3D;AACT,GAAG;AAIH;;;;;;;CAOC,GACD,OAAO,SAAS4D,oCACdhC,KAAc;IAEdzB,aACEyB,OACA8B,4BACA,0BACA3D,UAAU+C,aAAa;AAE3B;AAEA,MAAMe,mBAAmB9C,OAAO;IAC9BQ,IAAInB;IACJkB,SAASf;IACTuD,QAAQ7B;AACV;AAEA,MAAM8B,kBAAkBzD"}

package/dist/esm/iframe/IFrameSnapExecutor.js

@@ -1,35 +0,0 @@
-import ObjectMultiplex from '@metamask/object-multiplex';
-import { WindowPostMessageStream } from '@metamask/post-message-stream';
-import { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';
-import { pipeline } from 'readable-stream';
-import { BaseSnapExecutor } from '../common/BaseSnapExecutor';
-import { log } from '../logging';
-export class IFrameSnapExecutor extends 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 WindowPostMessageStream({
-        name: 'child',
-        target: 'parent',
-        targetWindow: self.parent,
-        targetOrigin: '*'
-    })) {
-        log('Worker: Connecting to parent.');
-        const mux = new ObjectMultiplex();
-        pipeline(stream, mux, stream, (error)=>{
-            if (error) {
-                logError(`Parent stream failure, closing worker.`, error);
-            }
-            self.close();
-        });
-        const commandStream = mux.createStream(SNAP_STREAM_NAMES.COMMAND);
-        const rpcStream = mux.createStream(SNAP_STREAM_NAMES.JSON_RPC);
-        return new IFrameSnapExecutor(commandStream, rpcStream);
-    }
-}
-
-//# sourceMappingURL=IFrameSnapExecutor.js.map

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

@@ -1 +0,0 @@
-{"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 'readable-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":["ObjectMultiplex","WindowPostMessageStream","logError","SNAP_STREAM_NAMES","pipeline","BaseSnapExecutor","log","IFrameSnapExecutor","initialize","stream","name","target","targetWindow","self","parent","targetOrigin","mux","error","close","commandStream","createStream","COMMAND","rpcStream","JSON_RPC"],"mappings":"AAAA,OAAOA,qBAAqB,6BAA6B;AAEzD,SAASC,uBAAuB,QAAQ,gCAAgC;AACxE,SAASC,QAAQ,EAAEC,iBAAiB,QAAQ,wBAAwB;AACpE,SAASC,QAAQ,QAAQ,kBAAkB;AAE3C,SAASC,gBAAgB,QAAQ,6BAA6B;AAC9D,SAASC,GAAG,QAAQ,aAAa;AAEjC,OAAO,MAAMC,2BAA2BF;IACtC;;;;;;;GAOC,GACD,OAAOG,WACLC,SAAgC,IAAIR,wBAAwB;QAC1DS,MAAM;QACNC,QAAQ;QACRC,cAAcC,KAAKC,MAAM;QACzBC,cAAc;IAChB,EAAE,EACF;QACAT,IAAI;QAEJ,MAAMU,MAAM,IAAIhB;QAChBI,SAASK,QAAQO,KAAKP,QAAQ,CAACQ;YAC7B,IAAIA,OAAO;gBACTf,SAAS,CAAC,sCAAsC,CAAC,EAAEe;YACrD;YACAJ,KAAKK,KAAK;QACZ;QAEA,MAAMC,gBAAgBH,IAAII,YAAY,CAACjB,kBAAkBkB,OAAO;QAChE,MAAMC,YAAYN,IAAII,YAAY,CAACjB,kBAAkBoB,QAAQ;QAE7D,OAAO,IAAIhB,mBAAmBY,eAAeG;IAC/C;AACF"}

package/dist/esm/iframe/index.js

@@ -1,9 +0,0 @@
-import { executeLockdownEvents } from '../common/lockdown/lockdown-events';
-import { executeLockdownMore } from '../common/lockdown/lockdown-more';
-import { IFrameSnapExecutor } from './IFrameSnapExecutor';
-// Lockdown is already applied in LavaMoat
-executeLockdownMore();
-executeLockdownEvents();
-IFrameSnapExecutor.initialize();
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"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":["executeLockdownEvents","executeLockdownMore","IFrameSnapExecutor","initialize"],"mappings":"AAAA,SAASA,qBAAqB,QAAQ,qCAAqC;AAC3E,SAASC,mBAAmB,QAAQ,mCAAmC;AACvE,SAASC,kBAAkB,QAAQ,uBAAuB;AAE1D,0CAA0C;AAC1CD;AACAD;AAEAE,mBAAmBC,UAAU"}

package/dist/esm/index.js

@@ -1,3 +0,0 @@
-export * from './proxy';
-
-//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './proxy';\n"],"names":[],"mappings":"AAAA,cAAc,UAAU"}

package/dist/esm/logging.js

@@ -1,10 +0,0 @@
-import { snapsLogger } from '@metamask/snaps-utils';
-import { createModuleLogger } from '@metamask/utils';
-/**
- * A logging function specific to this package. The log messages don't show up
- * by default, but they can be enabled by setting the environment variable:
- * - `DEBUG=metamask:snaps:snaps-execution-environments`, or
- * - `DEBUG=metamask:snaps:*` to enable all logs from `@metamask/snaps-*`.
- */ export const log = createModuleLogger(snapsLogger, 'snaps-execution-environments');
-
-//# sourceMappingURL=logging.js.map

package/dist/esm/logging.js.map

@@ -1 +0,0 @@
-{"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":["snapsLogger","createModuleLogger","log"],"mappings":"AAAA,SAASA,WAAW,QAAQ,wBAAwB;AACpD,SAASC,kBAAkB,QAAQ,kBAAkB;AAErD;;;;;CAKC,GACD,OAAO,MAAMC,MAAMD,mBACjBD,aACA,gCACA"}

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

@@ -1,24 +0,0 @@
-import ObjectMultiplex from '@metamask/object-multiplex';
-import { ProcessMessageStream } from '@metamask/post-message-stream';
-import { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';
-import { pipeline } from 'readable-stream';
-import { BaseSnapExecutor } from '../common/BaseSnapExecutor';
-import { log } from '../logging';
-export class ChildProcessSnapExecutor extends BaseSnapExecutor {
-    static initialize() {
-        log('Worker: Connecting to parent.');
-        const parentStream = new ProcessMessageStream();
-        const mux = new ObjectMultiplex();
-        pipeline(parentStream, mux, parentStream, (error)=>{
-            if (error) {
-                logError(`Parent stream failure, closing worker.`, error);
-            }
-            self.close();
-        });
-        const commandStream = mux.createStream(SNAP_STREAM_NAMES.COMMAND);
-        const rpcStream = mux.createStream(SNAP_STREAM_NAMES.JSON_RPC);
-        return new ChildProcessSnapExecutor(commandStream, rpcStream);
-    }
-}
-
-//# sourceMappingURL=ChildProcessSnapExecutor.js.map

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

@@ -1 +0,0 @@
-{"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 'readable-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":["ObjectMultiplex","ProcessMessageStream","logError","SNAP_STREAM_NAMES","pipeline","BaseSnapExecutor","log","ChildProcessSnapExecutor","initialize","parentStream","mux","error","self","close","commandStream","createStream","COMMAND","rpcStream","JSON_RPC"],"mappings":"AAAA,OAAOA,qBAAqB,6BAA6B;AACzD,SAASC,oBAAoB,QAAQ,gCAAgC;AACrE,SAASC,QAAQ,EAAEC,iBAAiB,QAAQ,wBAAwB;AACpE,SAASC,QAAQ,QAAQ,kBAAkB;AAE3C,SAASC,gBAAgB,QAAQ,6BAA6B;AAC9D,SAASC,GAAG,QAAQ,aAAa;AAEjC,OAAO,MAAMC,iCAAiCF;IAC5C,OAAOG,aAAa;QAClBF,IAAI;QAEJ,MAAMG,eAAe,IAAIR;QACzB,MAAMS,MAAM,IAAIV;QAChBI,SAASK,cAAcC,KAAYD,cAAc,CAACE;YAChD,IAAIA,OAAO;gBACTT,SAAS,CAAC,sCAAsC,CAAC,EAAES;YACrD;YACAC,KAAKC,KAAK;QACZ;QAEA,MAAMC,gBAAgBJ,IAAIK,YAAY,CAACZ,kBAAkBa,OAAO;QAChE,MAAMC,YAAYP,IAAIK,YAAY,CAACZ,kBAAkBe,QAAQ;QAC7D,OAAO,IAAIX,yBAAyBO,eAAeG;IACrD;AACF"}

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

@@ -1,7 +0,0 @@
-import { executeLockdownMore } from '../common/lockdown/lockdown-more';
-import { ChildProcessSnapExecutor } from './ChildProcessSnapExecutor';
-// Lockdown is already applied in LavaMoat
-executeLockdownMore();
-ChildProcessSnapExecutor.initialize();
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"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":"AAAA,SAASA,mBAAmB,QAAQ,mCAAmC;AACvE,SAASC,wBAAwB,QAAQ,6BAA6B;AAEtE,0CAA0C;AAC1CD;AAEAC,yBAAyBC,UAAU"}

package/dist/esm/node-thread/ThreadSnapExecutor.js

@@ -1,24 +0,0 @@
-import ObjectMultiplex from '@metamask/object-multiplex';
-import { ThreadMessageStream } from '@metamask/post-message-stream';
-import { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';
-import { pipeline } from 'readable-stream';
-import { BaseSnapExecutor } from '../common/BaseSnapExecutor';
-import { log } from '../logging';
-export class ThreadSnapExecutor extends BaseSnapExecutor {
-    static initialize() {
-        log('Worker: Connecting to parent.');
-        const parentStream = new ThreadMessageStream();
-        const mux = new ObjectMultiplex();
-        pipeline(parentStream, mux, parentStream, (error)=>{
-            if (error) {
-                logError(`Parent stream failure, closing worker.`, error);
-            }
-            self.close();
-        });
-        const commandStream = mux.createStream(SNAP_STREAM_NAMES.COMMAND);
-        const rpcStream = mux.createStream(SNAP_STREAM_NAMES.JSON_RPC);
-        return new ThreadSnapExecutor(commandStream, rpcStream);
-    }
-}
-
-//# sourceMappingURL=ThreadSnapExecutor.js.map

package/dist/esm/node-thread/ThreadSnapExecutor.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/node-thread/ThreadSnapExecutor.ts"],"sourcesContent":["import ObjectMultiplex from '@metamask/object-multiplex';\nimport { ThreadMessageStream } from '@metamask/post-message-stream';\nimport { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';\nimport { pipeline } from 'readable-stream';\n\nimport { BaseSnapExecutor } from '../common/BaseSnapExecutor';\nimport { log } from '../logging';\n\nexport class ThreadSnapExecutor extends BaseSnapExecutor {\n  static initialize() {\n    log('Worker: Connecting to parent.');\n\n    const parentStream = new ThreadMessageStream();\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 ThreadSnapExecutor(commandStream, rpcStream);\n  }\n}\n"],"names":["ObjectMultiplex","ThreadMessageStream","logError","SNAP_STREAM_NAMES","pipeline","BaseSnapExecutor","log","ThreadSnapExecutor","initialize","parentStream","mux","error","self","close","commandStream","createStream","COMMAND","rpcStream","JSON_RPC"],"mappings":"AAAA,OAAOA,qBAAqB,6BAA6B;AACzD,SAASC,mBAAmB,QAAQ,gCAAgC;AACpE,SAASC,QAAQ,EAAEC,iBAAiB,QAAQ,wBAAwB;AACpE,SAASC,QAAQ,QAAQ,kBAAkB;AAE3C,SAASC,gBAAgB,QAAQ,6BAA6B;AAC9D,SAASC,GAAG,QAAQ,aAAa;AAEjC,OAAO,MAAMC,2BAA2BF;IACtC,OAAOG,aAAa;QAClBF,IAAI;QAEJ,MAAMG,eAAe,IAAIR;QACzB,MAAMS,MAAM,IAAIV;QAChBI,SAASK,cAAcC,KAAYD,cAAc,CAACE;YAChD,IAAIA,OAAO;gBACTT,SAAS,CAAC,sCAAsC,CAAC,EAAES;YACrD;YACAC,KAAKC,KAAK;QACZ;QAEA,MAAMC,gBAAgBJ,IAAIK,YAAY,CAACZ,kBAAkBa,OAAO;QAChE,MAAMC,YAAYP,IAAIK,YAAY,CAACZ,kBAAkBe,QAAQ;QAC7D,OAAO,IAAIX,mBAAmBO,eAAeG;IAC/C;AACF"}