@metamask/snaps-execution-environments 3.0.0 → 3.2.0

package/dist/cjs/common/endowments/timeout.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/common/endowments/timeout.ts"],"sourcesContent":["const MINIMUM_TIMEOUT = 10;\n\n/**\n * Creates a pair of `setTimeout` and `clearTimeout` functions attenuated such\n * that:\n * - `setTimeout` throws if its \"handler\" parameter is not a function.\n * - `clearTimeout` only clears timeouts created by its sibling `setTimeout`,\n * or else no-ops.\n *\n * @returns An object with the attenuated `setTimeout` and `clearTimeout`\n * functions.\n */\nconst createTimeout = () => {\n  const registeredHandles = new Map<unknown, unknown>();\n  const _setTimeout = (handler: TimerHandler, timeout?: number): unknown => {\n    if (typeof handler !== 'function') {\n      throw new Error(\n        `The timeout handler must be a function. Received: ${typeof handler}`,\n      );\n    }\n    harden(handler);\n    const handle = Object.freeze(Object.create(null));\n    const platformHandle = setTimeout(() => {\n      registeredHandles.delete(handle);\n      handler();\n    }, Math.max(MINIMUM_TIMEOUT, timeout ?? 0));\n\n    registeredHandles.set(handle, platformHandle);\n    return handle;\n  };\n\n  const _clearTimeout = (handle: unknown): void => {\n    const platformHandle = registeredHandles.get(handle);\n    if (platformHandle !== undefined) {\n      clearTimeout(platformHandle as any);\n      registeredHandles.delete(handle);\n    }\n  };\n\n  const teardownFunction = (): void => {\n    for (const handle of registeredHandles.keys()) {\n      _clearTimeout(handle);\n    }\n  };\n\n  return {\n    setTimeout: harden(_setTimeout),\n    clearTimeout: harden(_clearTimeout),\n    teardownFunction,\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['setTimeout', 'clearTimeout'] as const,\n  factory: createTimeout,\n};\nexport default endowmentModule;\n"],"names":["MINIMUM_TIMEOUT","createTimeout","registeredHandles","Map","_setTimeout","handler","timeout","Error","harden","handle","Object","freeze","create","platformHandle","setTimeout","delete","Math","max","set","_clearTimeout","get","undefined","clearTimeout","teardownFunction","keys","endowmentModule","names","factory"],"mappings":";;;;+BAwDA;;;eAAA;;;AAxDA,MAAMA,kBAAkB;AAExB;;;;;;;;;CASC,GACD,MAAMC,gBAAgB;IACpB,MAAMC,oBAAoB,IAAIC;IAC9B,MAAMC,cAAc,CAACC,SAAuBC;QAC1C,IAAI,OAAOD,YAAY,YAAY;YACjC,MAAM,IAAIE,MACR,CAAC,kDAAkD,EAAE,OAAOF,QAAQ,CAAC;QAEzE;QACAG,OAAOH;QACP,MAAMI,SAASC,OAAOC,MAAM,CAACD,OAAOE,MAAM,CAAC;QAC3C,MAAMC,iBAAiBC,WAAW;YAChCZ,kBAAkBa,MAAM,CAACN;YACzBJ;QACF,GAAGW,KAAKC,GAAG,CAACjB,iBAAiBM,WAAW;QAExCJ,kBAAkBgB,GAAG,CAACT,QAAQI;QAC9B,OAAOJ;IACT;IAEA,MAAMU,gBAAgB,CAACV;QACrB,MAAMI,iBAAiBX,kBAAkBkB,GAAG,CAACX;QAC7C,IAAII,mBAAmBQ,WAAW;YAChCC,aAAaT;YACbX,kBAAkBa,MAAM,CAACN;QAC3B;IACF;IAEA,MAAMc,mBAAmB;QACvB,KAAK,MAAMd,UAAUP,kBAAkBsB,IAAI,GAAI;YAC7CL,cAAcV;QAChB;IACF;IAEA,OAAO;QACLK,YAAYN,OAAOJ;QACnBkB,cAAcd,OAAOW;QACrBI;IACF;AACF;AAEA,MAAME,kBAAkB;IACtBC,OAAO;QAAC;QAAc;KAAe;IACrCC,SAAS1B;AACX;MACA,WAAewB"}
+{"version":3,"sources":["../../../../src/common/endowments/timeout.ts"],"sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\n\nconst MINIMUM_TIMEOUT = 10;\n\n/**\n * Creates a pair of `setTimeout` and `clearTimeout` functions attenuated such\n * that:\n * - `setTimeout` throws if its \"handler\" parameter is not a function.\n * - `clearTimeout` only clears timeouts created by its sibling `setTimeout`,\n * or else no-ops.\n *\n * @returns An object with the attenuated `setTimeout` and `clearTimeout`\n * functions.\n */\nconst createTimeout = () => {\n  const registeredHandles = new Map<unknown, unknown>();\n  const _setTimeout = (handler: TimerHandler, timeout?: number): unknown => {\n    if (typeof handler !== 'function') {\n      throw rpcErrors.internal(\n        `The timeout handler must be a function. Received: ${typeof handler}.`,\n      );\n    }\n    harden(handler);\n    const handle = Object.freeze(Object.create(null));\n    const platformHandle = setTimeout(() => {\n      registeredHandles.delete(handle);\n      handler();\n    }, Math.max(MINIMUM_TIMEOUT, timeout ?? 0));\n\n    registeredHandles.set(handle, platformHandle);\n    return handle;\n  };\n\n  const _clearTimeout = (handle: unknown): void => {\n    const platformHandle = registeredHandles.get(handle);\n    if (platformHandle !== undefined) {\n      clearTimeout(platformHandle as any);\n      registeredHandles.delete(handle);\n    }\n  };\n\n  const teardownFunction = (): void => {\n    for (const handle of registeredHandles.keys()) {\n      _clearTimeout(handle);\n    }\n  };\n\n  return {\n    setTimeout: harden(_setTimeout),\n    clearTimeout: harden(_clearTimeout),\n    teardownFunction,\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['setTimeout', 'clearTimeout'] as const,\n  factory: createTimeout,\n};\nexport default endowmentModule;\n"],"names":["MINIMUM_TIMEOUT","createTimeout","registeredHandles","Map","_setTimeout","handler","timeout","rpcErrors","internal","harden","handle","Object","freeze","create","platformHandle","setTimeout","delete","Math","max","set","_clearTimeout","get","undefined","clearTimeout","teardownFunction","keys","endowmentModule","names","factory"],"mappings":";;;;+BA0DA;;;eAAA;;;2BA1D0B;AAE1B,MAAMA,kBAAkB;AAExB;;;;;;;;;CASC,GACD,MAAMC,gBAAgB;IACpB,MAAMC,oBAAoB,IAAIC;IAC9B,MAAMC,cAAc,CAACC,SAAuBC;QAC1C,IAAI,OAAOD,YAAY,YAAY;YACjC,MAAME,oBAAS,CAACC,QAAQ,CACtB,CAAC,kDAAkD,EAAE,OAAOH,QAAQ,CAAC,CAAC;QAE1E;QACAI,OAAOJ;QACP,MAAMK,SAASC,OAAOC,MAAM,CAACD,OAAOE,MAAM,CAAC;QAC3C,MAAMC,iBAAiBC,WAAW;YAChCb,kBAAkBc,MAAM,CAACN;YACzBL;QACF,GAAGY,KAAKC,GAAG,CAAClB,iBAAiBM,WAAW;QAExCJ,kBAAkBiB,GAAG,CAACT,QAAQI;QAC9B,OAAOJ;IACT;IAEA,MAAMU,gBAAgB,CAACV;QACrB,MAAMI,iBAAiBZ,kBAAkBmB,GAAG,CAACX;QAC7C,IAAII,mBAAmBQ,WAAW;YAChCC,aAAaT;YACbZ,kBAAkBc,MAAM,CAACN;QAC3B;IACF;IAEA,MAAMc,mBAAmB;QACvB,KAAK,MAAMd,UAAUR,kBAAkBuB,IAAI,GAAI;YAC7CL,cAAcV;QAChB;IACF;IAEA,OAAO;QACLK,YAAYN,OAAOL;QACnBmB,cAAcd,OAAOW;QACrBI;IACF;AACF;AAEA,MAAME,kBAAkB;IACtBC,OAAO;QAAC;QAAc;KAAe;IACrCC,SAAS3B;AACX;MACA,WAAeyB"}

package/dist/cjs/common/globalEvents.js

@@ -16,6 +16,7 @@ _export(exports, {
         return removeEventListener;
     }
 });
+const _rpcerrors = require("@metamask/rpc-errors");
 const _globalObject = require("./globalObject");
 function addEventListener(event, listener) {
     if ('addEventListener' in _globalObject.rootRealmGlobal && typeof _globalObject.rootRealmGlobal.addEventListener === 'function') {
@@ -24,7 +25,7 @@ function addEventListener(event, listener) {
     if (_globalObject.rootRealmGlobal.process && 'on' in _globalObject.rootRealmGlobal.process && typeof _globalObject.rootRealmGlobal.process.on === 'function') {
         return _globalObject.rootRealmGlobal.process.on(event, listener);
     }
-    throw new Error('Platform agnostic addEventListener failed');
+    throw _rpcerrors.rpcErrors.internal('Platform agnostic addEventListener failed.');
 }
 function removeEventListener(event, listener) {
     if ('removeEventListener' in _globalObject.rootRealmGlobal && typeof _globalObject.rootRealmGlobal.removeEventListener === 'function') {

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/common/globalEvents.ts"],"sourcesContent":["import { rootRealmGlobal } from './globalObject';\n\n/**\n * Adds an event listener platform agnostically, trying both `globalThis.addEventListener` and `globalThis.process.on`\n *\n * @param event - The event to listen for.\n * @param listener - The listener to be triggered when the event occurs.\n * @returns The result of the platform agnostic operation if any.\n * @throws If none of the platform options are present.\n */\nexport function addEventListener(\n  event: string,\n  listener: (...args: any[]) => void,\n) {\n  if (\n    'addEventListener' in rootRealmGlobal &&\n    typeof rootRealmGlobal.addEventListener === 'function'\n  ) {\n    return rootRealmGlobal.addEventListener(event.toLowerCase(), listener);\n  }\n\n  if (\n    rootRealmGlobal.process &&\n    'on' in rootRealmGlobal.process &&\n    typeof rootRealmGlobal.process.on === 'function'\n  ) {\n    return rootRealmGlobal.process.on(event, listener);\n  }\n\n  throw new Error('Platform agnostic addEventListener failed');\n}\n\n/**\n * Removes an event listener platform agnostically, trying both `globalThis.removeEventListener` and `globalThis.process.removeListener`\n *\n * @param event - The event to remove the listener for.\n * @param listener - The currently attached listener.\n * @returns The result of the platform agnostic operation if any.\n * @throws If none of the platform options are present.\n */\nexport function removeEventListener(\n  event: string,\n  listener: (...args: any[]) => void,\n) {\n  if (\n    'removeEventListener' in rootRealmGlobal &&\n    typeof rootRealmGlobal.removeEventListener === 'function'\n  ) {\n    return rootRealmGlobal.removeEventListener(event.toLowerCase(), listener);\n  }\n\n  if (\n    rootRealmGlobal.process &&\n    'removeListener' in rootRealmGlobal.process &&\n    typeof rootRealmGlobal.process.removeListener === 'function'\n  ) {\n    return rootRealmGlobal.process.removeListener(event, listener);\n  }\n\n  throw new Error('Platform agnostic removeEventListener failed');\n}\n"],"names":["addEventListener","removeEventListener","event","listener","rootRealmGlobal","toLowerCase","process","on","Error","removeListener"],"mappings":";;;;;;;;;;;IAUgBA,gBAAgB;eAAhBA;;IA8BAC,mBAAmB;eAAnBA;;;8BAxCgB;AAUzB,SAASD,iBACdE,KAAa,EACbC,QAAkC;IAElC,IACE,sBAAsBC,6BAAe,IACrC,OAAOA,6BAAe,CAACJ,gBAAgB,KAAK,YAC5C;QACA,OAAOI,6BAAe,CAACJ,gBAAgB,CAACE,MAAMG,WAAW,IAAIF;IAC/D;IAEA,IACEC,6BAAe,CAACE,OAAO,IACvB,QAAQF,6BAAe,CAACE,OAAO,IAC/B,OAAOF,6BAAe,CAACE,OAAO,CAACC,EAAE,KAAK,YACtC;QACA,OAAOH,6BAAe,CAACE,OAAO,CAACC,EAAE,CAACL,OAAOC;IAC3C;IAEA,MAAM,IAAIK,MAAM;AAClB;AAUO,SAASP,oBACdC,KAAa,EACbC,QAAkC;IAElC,IACE,yBAAyBC,6BAAe,IACxC,OAAOA,6BAAe,CAACH,mBAAmB,KAAK,YAC/C;QACA,OAAOG,6BAAe,CAACH,mBAAmB,CAACC,MAAMG,WAAW,IAAIF;IAClE;IAEA,IACEC,6BAAe,CAACE,OAAO,IACvB,oBAAoBF,6BAAe,CAACE,OAAO,IAC3C,OAAOF,6BAAe,CAACE,OAAO,CAACG,cAAc,KAAK,YAClD;QACA,OAAOL,6BAAe,CAACE,OAAO,CAACG,cAAc,CAACP,OAAOC;IACvD;IAEA,MAAM,IAAIK,MAAM;AAClB"}
+{"version":3,"sources":["../../../src/common/globalEvents.ts"],"sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\n\nimport { rootRealmGlobal } from './globalObject';\n\n/**\n * Adds an event listener platform agnostically, trying both `globalThis.addEventListener` and `globalThis.process.on`\n *\n * @param event - The event to listen for.\n * @param listener - The listener to be triggered when the event occurs.\n * @returns The result of the platform agnostic operation if any.\n * @throws If none of the platform options are present.\n */\nexport function addEventListener(\n  event: string,\n  listener: (...args: any[]) => void,\n) {\n  if (\n    'addEventListener' in rootRealmGlobal &&\n    typeof rootRealmGlobal.addEventListener === 'function'\n  ) {\n    return rootRealmGlobal.addEventListener(event.toLowerCase(), listener);\n  }\n\n  if (\n    rootRealmGlobal.process &&\n    'on' in rootRealmGlobal.process &&\n    typeof rootRealmGlobal.process.on === 'function'\n  ) {\n    return rootRealmGlobal.process.on(event, listener);\n  }\n\n  throw rpcErrors.internal('Platform agnostic addEventListener failed.');\n}\n\n/**\n * Removes an event listener platform agnostically, trying both `globalThis.removeEventListener` and `globalThis.process.removeListener`\n *\n * @param event - The event to remove the listener for.\n * @param listener - The currently attached listener.\n * @returns The result of the platform agnostic operation if any.\n * @throws If none of the platform options are present.\n */\nexport function removeEventListener(\n  event: string,\n  listener: (...args: any[]) => void,\n) {\n  if (\n    'removeEventListener' in rootRealmGlobal &&\n    typeof rootRealmGlobal.removeEventListener === 'function'\n  ) {\n    return rootRealmGlobal.removeEventListener(event.toLowerCase(), listener);\n  }\n\n  if (\n    rootRealmGlobal.process &&\n    'removeListener' in rootRealmGlobal.process &&\n    typeof rootRealmGlobal.process.removeListener === 'function'\n  ) {\n    return rootRealmGlobal.process.removeListener(event, listener);\n  }\n\n  throw new Error('Platform agnostic removeEventListener failed');\n}\n"],"names":["addEventListener","removeEventListener","event","listener","rootRealmGlobal","toLowerCase","process","on","rpcErrors","internal","removeListener","Error"],"mappings":";;;;;;;;;;;IAYgBA,gBAAgB;eAAhBA;;IA8BAC,mBAAmB;eAAnBA;;;2BA1CU;8BAEM;AAUzB,SAASD,iBACdE,KAAa,EACbC,QAAkC;IAElC,IACE,sBAAsBC,6BAAe,IACrC,OAAOA,6BAAe,CAACJ,gBAAgB,KAAK,YAC5C;QACA,OAAOI,6BAAe,CAACJ,gBAAgB,CAACE,MAAMG,WAAW,IAAIF;IAC/D;IAEA,IACEC,6BAAe,CAACE,OAAO,IACvB,QAAQF,6BAAe,CAACE,OAAO,IAC/B,OAAOF,6BAAe,CAACE,OAAO,CAACC,EAAE,KAAK,YACtC;QACA,OAAOH,6BAAe,CAACE,OAAO,CAACC,EAAE,CAACL,OAAOC;IAC3C;IAEA,MAAMK,oBAAS,CAACC,QAAQ,CAAC;AAC3B;AAUO,SAASR,oBACdC,KAAa,EACbC,QAAkC;IAElC,IACE,yBAAyBC,6BAAe,IACxC,OAAOA,6BAAe,CAACH,mBAAmB,KAAK,YAC/C;QACA,OAAOG,6BAAe,CAACH,mBAAmB,CAACC,MAAMG,WAAW,IAAIF;IAClE;IAEA,IACEC,6BAAe,CAACE,OAAO,IACvB,oBAAoBF,6BAAe,CAACE,OAAO,IAC3C,OAAOF,6BAAe,CAACE,OAAO,CAACI,cAAc,KAAK,YAClD;QACA,OAAON,6BAAe,CAACE,OAAO,CAACI,cAAc,CAACR,OAAOC;IACvD;IAEA,MAAM,IAAIQ,MAAM;AAClB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/common/globalObject.ts"],"sourcesContent":["enum GlobalObjectNames {\n  // The globalThis entry is incorrectly identified as shadowing the global\n  // globalThis.\n  /* eslint-disable @typescript-eslint/naming-convention */\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  globalThis = 'globalThis',\n  global = 'global',\n  self = 'self',\n  window = 'window',\n  /* eslint-enavle @typescript-eslint/naming-convention */\n}\n\nlet _rootRealmGlobal: typeof globalThis;\nlet _rootRealmGlobalName: string;\n\n/* istanbul ignore next */\n/* eslint-disable no-negated-condition */\nif (typeof globalThis !== 'undefined') {\n  _rootRealmGlobal = globalThis;\n  _rootRealmGlobalName = GlobalObjectNames.globalThis;\n} else if (typeof self !== 'undefined') {\n  _rootRealmGlobal = self;\n  _rootRealmGlobalName = GlobalObjectNames.self;\n} else if (typeof window !== 'undefined') {\n  _rootRealmGlobal = window;\n  _rootRealmGlobalName = GlobalObjectNames.window;\n} else if (typeof global !== 'undefined') {\n  _rootRealmGlobal = global;\n  _rootRealmGlobalName = GlobalObjectNames.global;\n} else {\n  throw new Error('Unknown realm type; failed to identify global object.');\n}\n/* eslint-enable no-negated-condition */\n\n/**\n * A platform-agnostic alias for the root realm global object.\n */\nconst rootRealmGlobal = _rootRealmGlobal;\n\n/**\n * The string literal corresponding to the name of the root realm global object.\n */\nconst rootRealmGlobalName = _rootRealmGlobalName;\n\nexport { rootRealmGlobal, rootRealmGlobalName };\n"],"names":["rootRealmGlobal","rootRealmGlobalName","GlobalObjectNames","globalThis","global","self","window","_rootRealmGlobal","_rootRealmGlobalName","Error"],"mappings":";;;;;;;;;;;IA4CSA,eAAe;eAAfA;;IAAiBC,mBAAmB;eAAnBA;;;IA5C1B;UAAKC,iBAAiB;IAAjBA,kBACH,yEAAyE;IACzE,cAAc;IACd,uDAAuD,GACvD,wDAAwD;IACxDC,gBAAAA;IALGD,kBAMHE,YAAAA;IANGF,kBAOHG,UAAAA;IAPGH,kBAQHI,YAAAA;GARGJ,sBAAAA;AAYL,IAAIK;AACJ,IAAIC;AAEJ,wBAAwB,GACxB,uCAAuC,GACvC,IAAI,OAAOL,eAAe,aAAa;IACrCI,mBAAmBJ;IACnBK,uBAAuBN,kBAAkBC,UAAU;AACrD,OAAO,IAAI,OAAOE,SAAS,aAAa;IACtCE,mBAAmBF;IACnBG,uBAAuBN,kBAAkBG,IAAI;AAC/C,OAAO,IAAI,OAAOC,WAAW,aAAa;IACxCC,mBAAmBD;IACnBE,uBAAuBN,kBAAkBI,MAAM;AACjD,OAAO,IAAI,OAAOF,WAAW,aAAa;IACxCG,mBAAmBH;IACnBI,uBAAuBN,kBAAkBE,MAAM;AACjD,OAAO;IACL,MAAM,IAAIK,MAAM;AAClB;AACA,sCAAsC,GAEtC;;CAEC,GACD,MAAMT,kBAAkBO;AAExB;;CAEC,GACD,MAAMN,sBAAsBO"}
+{"version":3,"sources":["../../../src/common/globalObject.ts"],"sourcesContent":["enum GlobalObjectNames {\n  // The globalThis entry is incorrectly identified as shadowing the global\n  // globalThis.\n  /* eslint-disable @typescript-eslint/naming-convention */\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  globalThis = 'globalThis',\n  global = 'global',\n  self = 'self',\n  window = 'window',\n  /* eslint-enable @typescript-eslint/naming-convention */\n}\n\nlet _rootRealmGlobal: typeof globalThis;\nlet _rootRealmGlobalName: string;\n\n/* istanbul ignore next */\n/* eslint-disable no-negated-condition */\nif (typeof globalThis !== 'undefined') {\n  _rootRealmGlobal = globalThis;\n  _rootRealmGlobalName = GlobalObjectNames.globalThis;\n} else if (typeof self !== 'undefined') {\n  _rootRealmGlobal = self;\n  _rootRealmGlobalName = GlobalObjectNames.self;\n} else if (typeof window !== 'undefined') {\n  _rootRealmGlobal = window;\n  _rootRealmGlobalName = GlobalObjectNames.window;\n} else if (typeof global !== 'undefined') {\n  _rootRealmGlobal = global;\n  _rootRealmGlobalName = GlobalObjectNames.global;\n} else {\n  throw new Error('Unknown realm type; failed to identify global object.');\n}\n/* eslint-enable no-negated-condition */\n\n/**\n * A platform-agnostic alias for the root realm global object.\n */\nconst rootRealmGlobal = _rootRealmGlobal;\n\n/**\n * The string literal corresponding to the name of the root realm global object.\n */\nconst rootRealmGlobalName = _rootRealmGlobalName;\n\nexport { rootRealmGlobal, rootRealmGlobalName };\n"],"names":["rootRealmGlobal","rootRealmGlobalName","GlobalObjectNames","globalThis","global","self","window","_rootRealmGlobal","_rootRealmGlobalName","Error"],"mappings":";;;;;;;;;;;IA4CSA,eAAe;eAAfA;;IAAiBC,mBAAmB;eAAnBA;;;IA5C1B;UAAKC,iBAAiB;IAAjBA,kBACH,yEAAyE;IACzE,cAAc;IACd,uDAAuD,GACvD,wDAAwD;IACxDC,gBAAAA;IALGD,kBAMHE,YAAAA;IANGF,kBAOHG,UAAAA;IAPGH,kBAQHI,YAAAA;GARGJ,sBAAAA;AAYL,IAAIK;AACJ,IAAIC;AAEJ,wBAAwB,GACxB,uCAAuC,GACvC,IAAI,OAAOL,eAAe,aAAa;IACrCI,mBAAmBJ;IACnBK,uBAAuBN,kBAAkBC,UAAU;AACrD,OAAO,IAAI,OAAOE,SAAS,aAAa;IACtCE,mBAAmBF;IACnBG,uBAAuBN,kBAAkBG,IAAI;AAC/C,OAAO,IAAI,OAAOC,WAAW,aAAa;IACxCC,mBAAmBD;IACnBE,uBAAuBN,kBAAkBI,MAAM;AACjD,OAAO,IAAI,OAAOF,WAAW,aAAa;IACxCG,mBAAmBH;IACnBI,uBAAuBN,kBAAkBE,MAAM;AACjD,OAAO;IACL,MAAM,IAAIK,MAAM;AAClB;AACA,sCAAsC,GAEtC;;CAEC,GACD,MAAMT,kBAAkBO;AAExB;;CAEC,GACD,MAAMN,sBAAsBO"}

package/dist/cjs/common/utils.js

@@ -9,9 +9,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    constructError: function() {
-        return constructError;
-    },
     withTeardown: function() {
         return withTeardown;
     },
@@ -31,20 +28,9 @@ _export(exports, {
         return sanitizeRequestArguments;
     }
 });
+const _rpcerrors = require("@metamask/rpc-errors");
 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)=>{
@@ -109,27 +95,27 @@ const BLOCKED_RPC_METHODS = Object.freeze([
 ]);
 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({
+    (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_*`.', _rpcerrors.rpcErrors.methodNotSupported);
+    (0, _utils.assert)(!BLOCKED_RPC_METHODS.includes(args.method), _rpcerrors.rpcErrors.methodNotFound({
         data: {
             method: args.method
         }
     }));
-    (0, _utils.assertStruct)(args, _utils.JsonStruct, 'Provided value is not JSON-RPC compatible');
+    (0, _utils.assertStruct)(args, _utils.JsonStruct, 'Provided value is not JSON-RPC compatible', _rpcerrors.rpcErrors.invalidParams);
 }
 function assertEthereumOutboundRequest(args) {
     // Disallow snaps methods for separation of concerns.
-    (0, _utils.assert)(!String.prototype.startsWith.call(args.method, 'snap_'), _ethrpcerrors.ethErrors.rpc.methodNotFound({
+    (0, _utils.assert)(!String.prototype.startsWith.call(args.method, 'snap_'), _rpcerrors.rpcErrors.methodNotFound({
         data: {
             method: args.method
         }
     }));
-    (0, _utils.assert)(!BLOCKED_RPC_METHODS.includes(args.method), _ethrpcerrors.ethErrors.rpc.methodNotFound({
+    (0, _utils.assert)(!BLOCKED_RPC_METHODS.includes(args.method), _rpcerrors.rpcErrors.methodNotFound({
         data: {
             method: args.method
         }
     }));
-    (0, _utils.assertStruct)(args, _utils.JsonStruct, 'Provided value is not JSON-RPC compatible');
+    (0, _utils.assertStruct)(args, _utils.JsonStruct, 'Provided value is not JSON-RPC compatible', _rpcerrors.rpcErrors.invalidParams);
 }
 function sanitizeRequestArguments(value) {
     // Before passing to getSafeJson we run the value through JSON serialization.

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

@@ -1 +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, getSafeJson, 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\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":["constructError","withTeardown","proxyStreamProvider","BLOCKED_RPC_METHODS","assertSnapOutboundRequest","assertEthereumOutboundRequest","sanitizeRequestArguments","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","json","JSON","parse","stringify","getSafeJson"],"mappings":"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"}
+{"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  // 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":["withTeardown","proxyStreamProvider","BLOCKED_RPC_METHODS","assertSnapOutboundRequest","assertEthereumOutboundRequest","sanitizeRequestArguments","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","rpcErrors","methodNotSupported","methodNotFound","data","assertStruct","JsonStruct","invalidParams","json","JSON","parse","stringify","getSafeJson"],"mappings":"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"}

package/dist/cjs/common/validation.js

@@ -46,6 +46,7 @@ _export(exports, {
         return assertIsOnNameLookupRequestArguments;
     }
 });
+const _rpcerrors = require("@metamask/rpc-errors");
 const _snapsutils = require("@metamask/snaps-utils");
 const _utils = require("@metamask/utils");
 const _superstruct = require("superstruct");
@@ -90,7 +91,7 @@ const OnTransactionRequestArgumentsStruct = (0, _superstruct.object)({
     transactionOrigin: (0, _superstruct.nullable)((0, _superstruct.string)())
 });
 function assertIsOnTransactionRequestArguments(value) {
-    (0, _utils.assertStruct)(value, OnTransactionRequestArgumentsStruct, 'Invalid request params');
+    (0, _utils.assertStruct)(value, OnTransactionRequestArgumentsStruct, 'Invalid request params', _rpcerrors.rpcErrors.invalidParams);
 }
 const baseNameLookupArgs = {
     chainId: _snapsutils.ChainIdStruct
@@ -108,7 +109,7 @@ const OnNameLookupRequestArgumentsStruct = (0, _superstruct.union)([
     addressRequestStruct
 ]);
 function assertIsOnNameLookupRequestArguments(value) {
-    (0, _utils.assertStruct)(value, OnNameLookupRequestArgumentsStruct, 'Invalid request params');
+    (0, _utils.assertStruct)(value, OnNameLookupRequestArgumentsStruct, 'Invalid request params', _rpcerrors.rpcErrors.invalidParams);
 }
 const OkResponseStruct = (0, _superstruct.assign)(_utils.JsonRpcSuccessStruct, (0, _superstruct.object)({
     result: OkStruct

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

@@ -1 +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"}
+{"version":3,"sources":["../../../src/common/validation.ts"],"sourcesContent":["import { rpcErrors } from '@metamask/rpc-errors';\nimport { 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    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\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","rpcErrors","invalidParams","baseNameLookupArgs","domainRequestStruct","address","addressRequestStruct","domain","OkResponseStruct","JsonRpcSuccessStruct","result","SnapRpcResponse"],"mappings":";;;;;;;;;;;IA2BaA,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;;IAqBHC,kCAAkC;eAAlCA;;IAsBGC,oCAAoC;eAApCA;;;2BA3KU;4BACiB;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,0BACAoC,oBAAS,CAACC,aAAa;AAE3B;AAEA,MAAMC,qBAAqB;IAAEP,SAASC,yBAAa;AAAC;AACpD,MAAMO,sBAAsBhC,IAAAA,mBAAM,EAAC;IACjC,GAAG+B,kBAAkB;IACrBE,SAAS7B,IAAAA,mBAAM;AACjB;AACA,MAAM8B,uBAAuBlC,IAAAA,mBAAM,EAAC;IAClC,GAAG+B,kBAAkB;IACrBI,QAAQ/B,IAAAA,mBAAM;AAChB;AAEO,MAAMT,qCAAqCiB,IAAAA,kBAAK,EAAC;IACtDoB;IACAE;CACD;AAmBM,SAAStC,qCACdS,KAAc;IAEduB,IAAAA,mBAAY,EACVvB,OACAV,oCACA,0BACAkC,oBAAS,CAACC,aAAa;AAE3B;AAEA,MAAMM,mBAAmBvC,IAAAA,mBAAM,EAC7BwC,2BAAoB,EACpBrC,IAAAA,mBAAM,EAAC;IACLsC,QAAQ5B;AACV;AAGF,MAAM6B,kBAAkBF,2BAAoB"}

package/dist/esm/common/BaseSnapExecutor.js

@@ -1,5 +1,20 @@
 // eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment
 /// <reference path="../../../../node_modules/ses/types.d.ts" />
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -13,23 +28,26 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+import { createIdRemapMiddleware } from '@metamask/json-rpc-engine';
 import { StreamProvider } from '@metamask/providers';
-import { SNAP_EXPORT_NAMES, logError, SNAP_EXPORTS } from '@metamask/snaps-utils';
+import { errorCodes, rpcErrors, serializeError } from '@metamask/rpc-errors';
+import { SNAP_EXPORT_NAMES, logError, SNAP_EXPORTS, WrappedSnapError, getErrorData, unwrapError } from '@metamask/snaps-utils';
 import { isObject, isValidJson, assert, isJsonRpcRequest, hasProperty, getSafeJson } from '@metamask/utils';
-import { errorCodes, ethErrors, serializeError } from 'eth-rpc-errors';
-import { createIdRemapMiddleware } from 'json-rpc-engine';
 import { validate } from 'superstruct';
 import { log } from '../logging';
 import { getCommandMethodImplementations } from './commands';
 import { createEndowments } from './endowments';
 import { addEventListener, removeEventListener } from './globalEvents';
 import { sortParamKeys } from './sortParams';
-import { assertEthereumOutboundRequest, assertSnapOutboundRequest, constructError, sanitizeRequestArguments, proxyStreamProvider, withTeardown } from './utils';
+import { assertEthereumOutboundRequest, assertSnapOutboundRequest, sanitizeRequestArguments, proxyStreamProvider, withTeardown } from './utils';
 import { ExecuteSnapRequestArgumentsStruct, PingRequestArgumentsStruct, SnapRpcRequestArgumentsStruct, TerminateRequestArgumentsStruct } from './validation';
 const fallbackError = {
     code: errorCodes.rpc.internal,
     message: 'Execution Environment Error'
 };
+const unhandledError = rpcErrors.internal({
+    message: 'Unhandled Snap Error'
+}).serialize();
 /**
  * The supported methods in the execution environment. The validator checks the
  * incoming JSON-RPC request, and the `params` property is used for sorting the
@@ -61,36 +79,40 @@ const fallbackError = {
         ]
     }
 };
+var _write = /*#__PURE__*/ new WeakSet(), _notify = /*#__PURE__*/ new WeakSet(), _respond = /*#__PURE__*/ new WeakSet();
 export class BaseSnapExecutor {
     errorHandler(error, data) {
-        const constructedError = constructError(error);
-        const serializedError = serializeError(constructedError, {
-            fallbackError,
+        const serializedError = serializeError(error, {
+            fallbackError: unhandledError,
             shouldIncludeStack: false
         });
-        // We're setting it this way to avoid sentData.stack = undefined
-        const sentData = {
-            ...data,
-            stack: constructedError?.stack ?? null
-        };
-        this.notify({
+        const errorData = getErrorData(serializedError);
+        _class_private_method_get(this, _notify, notify).call(this, {
             method: 'UnhandledError',
             params: {
                 error: {
                     ...serializedError,
-                    data: sentData
+                    data: {
+                        ...errorData,
+                        ...data
+                    }
                 }
             }
+        }).catch((notifyError)=>{
+            logError(notifyError);
         });
     }
     async onCommandRequest(message) {
         if (!isJsonRpcRequest(message)) {
-            throw new Error('Command stream received a non-JSON-RPC request.');
+            throw rpcErrors.invalidRequest({
+                message: 'Command stream received a non-JSON-RPC request.',
+                data: message
+            });
         }
         const { id, method, params } = message;
         if (!hasProperty(EXECUTION_ENVIRONMENT_METHODS, method)) {
-            this.respond(id, {
-                error: ethErrors.rpc.methodNotFound({
+            await _class_private_method_get(this, _respond, respond).call(this, id, {
+                error: rpcErrors.methodNotFound({
                     data: {
                         method
                     }
@@ -103,8 +125,8 @@ export class BaseSnapExecutor {
         const paramsAsArray = sortParamKeys(methodObject.params, params);
         const [error] = validate(paramsAsArray, methodObject.struct);
         if (error) {
-            this.respond(id, {
-                error: ethErrors.rpc.invalidParams({
+            await _class_private_method_get(this, _respond, respond).call(this, id, {
+                error: rpcErrors.invalidParams({
                     message: `Invalid parameters for method "${method}": ${error.message}.`,
                     data: {
                         method,
@@ -116,45 +138,17 @@ export class BaseSnapExecutor {
         }
         try {
             const result = await this.methods[method](...paramsAsArray);
-            this.respond(id, {
+            await _class_private_method_get(this, _respond, respond).call(this, id, {
                 result
             });
         } catch (rpcError) {
-            this.respond(id, {
+            await _class_private_method_get(this, _respond, respond).call(this, id, {
                 error: serializeError(rpcError, {
                     fallbackError
                 })
             });
         }
     }
-    notify(requestObject) {
-        if (!isValidJson(requestObject) || !isObject(requestObject)) {
-            throw new Error('JSON-RPC notifications must be JSON serializable objects');
-        }
-        this.commandStream.write({
-            ...requestObject,
-            jsonrpc: '2.0'
-        });
-    }
-    respond(id, requestObject) {
-        if (!isValidJson(requestObject) || !isObject(requestObject)) {
-            // Instead of throwing, we directly respond with an error.
-            // This prevents an issue where we wouldn't respond when errors were non-serializable
-            this.commandStream.write({
-                error: serializeError(new Error('JSON-RPC responses must be JSON serializable objects.'), {
-                    fallbackError
-                }),
-                id,
-                jsonrpc: '2.0'
-            });
-            return;
-        }
-        this.commandStream.write({
-            ...requestObject,
-            id,
-            jsonrpc: '2.0'
-        });
-    }
     /**
    * Attempts to evaluate a snap in SES. Generates APIs for the snap. May throw
    * on errors.
@@ -223,7 +217,13 @@ export class BaseSnapExecutor {
             });
         } catch (error) {
             this.removeSnap(snapId);
-            throw new Error(`Error while running snap '${snapId}': ${error.message}`);
+            const [cause] = unwrapError(error);
+            throw rpcErrors.internal({
+                message: `Error while running snap '${snapId}': ${cause.message}`,
+                data: {
+                    cause: cause.serialize()
+                }
+            });
         }
     }
     /**
@@ -264,16 +264,18 @@ export class BaseSnapExecutor {
         const request = async (args)=>{
             const sanitizedArgs = sanitizeRequestArguments(args);
             assertSnapOutboundRequest(sanitizedArgs);
-            this.notify({
-                method: 'OutboundRequest'
-            });
-            try {
-                return await withTeardown(originalRequest(sanitizedArgs), this);
-            } finally{
-                this.notify({
-                    method: 'OutboundResponse'
+            return await withTeardown((async ()=>{
+                await _class_private_method_get(this, _notify, notify).call(this, {
+                    method: 'OutboundRequest'
                 });
-            }
+                try {
+                    return await originalRequest(sanitizedArgs);
+                } finally{
+                    await _class_private_method_get(this, _notify, notify).call(this, {
+                        method: 'OutboundResponse'
+                    });
+                }
+            })(), this);
         };
         // Proxy target is intentionally set to be an empty object, to ensure
         // that access to the prototype chain is not possible.
@@ -302,16 +304,18 @@ export class BaseSnapExecutor {
         const request = async (args)=>{
             const sanitizedArgs = sanitizeRequestArguments(args);
             assertEthereumOutboundRequest(sanitizedArgs);
-            this.notify({
-                method: 'OutboundRequest'
-            });
-            try {
-                return await withTeardown(originalRequest(sanitizedArgs), this);
-            } finally{
-                this.notify({
-                    method: 'OutboundResponse'
+            return await withTeardown((async ()=>{
+                await _class_private_method_get(this, _notify, notify).call(this, {
+                    method: 'OutboundRequest'
                 });
-            }
+                try {
+                    return await originalRequest(sanitizedArgs);
+                } finally{
+                    await _class_private_method_get(this, _notify, notify).call(this, {
+                        method: 'OutboundResponse'
+                    });
+                }
+            })(), this);
         };
         const streamProviderProxy = proxyStreamProvider(provider, request);
         return harden(streamProviderProxy);
@@ -336,11 +340,11 @@ export class BaseSnapExecutor {
    */ async executeInSnapContext(snapId, executor) {
         const data = this.snapData.get(snapId);
         if (data === undefined) {
-            throw new Error(`Tried to execute in context of unknown snap: "${snapId}".`);
+            throw rpcErrors.internal(`Tried to execute in context of unknown snap: "${snapId}".`);
         }
         let stop;
         const stopPromise = new Promise((_, reject)=>stop = ()=>reject(// TODO(rekmarks): Specify / standardize error code for this case.
-                ethErrors.rpc.internal(`The snap "${snapId}" has been terminated during execution.`)));
+                rpcErrors.internal(`The snap "${snapId}" has been terminated during execution.`)));
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const evaluationData = {
             stop: stop
@@ -354,6 +358,8 @@ export class BaseSnapExecutor {
                 executor(),
                 stopPromise
             ]);
+        } catch (error) {
+            throw new WrappedSnapError(error);
         } finally{
             data.runningEvaluations.delete(evaluationData);
             if (data.runningEvaluations.size === 0) {
@@ -363,6 +369,12 @@ export class BaseSnapExecutor {
         }
     }
     constructor(commandStream, rpcStream){
+        // Awaitable function that writes back to the command stream
+        // To prevent snap execution from blocking writing we wrap in a promise
+        // and await it before continuing execution
+        _class_private_method_init(this, _write);
+        _class_private_method_init(this, _notify);
+        _class_private_method_init(this, _respond);
         _define_property(this, "snapData", void 0);
         _define_property(this, "commandStream", void 0);
         _define_property(this, "rpcStream", void 0);
@@ -385,14 +397,14 @@ export class BaseSnapExecutor {
             // before the call.
             const handler = data?.exports[handlerType];
             const { required } = SNAP_EXPORTS[handlerType];
-            assert(!required || handler !== undefined, `No ${handlerType} handler exported for snap "${target}`);
+            assert(!required || handler !== undefined, `No ${handlerType} handler exported for snap "${target}`, rpcErrors.methodNotSupported);
             // Certain handlers are not required. If they are not exported, we
             // return null.
             if (!handler) {
                 return null;
             }
-            // TODO: fix handler args type cast
-            let result = await this.executeInSnapContext(target, ()=>handler(args));
+            let result = await this.executeInSnapContext(target, ()=>// TODO: fix handler args type cast
+                handler(args));
             // The handler might not return anything, but undefined is not valid JSON.
             if (result === undefined) {
                 result = null;
@@ -401,10 +413,47 @@ export class BaseSnapExecutor {
             try {
                 return getSafeJson(result);
             } catch (error) {
-                throw new TypeError(`Received non-JSON-serializable value: ${error.message.replace(/^Assertion failed: /u, '')}`);
+                throw rpcErrors.internal(`Received non-JSON-serializable value: ${error.message.replace(/^Assertion failed: /u, '')}`);
             }
         }, this.onTerminate.bind(this));
     }
 }
+async function write(chunk) {
+    return new Promise((resolve, reject)=>{
+        this.commandStream.write(chunk, (error)=>{
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function notify(requestObject) {
+    if (!isValidJson(requestObject) || !isObject(requestObject)) {
+        throw rpcErrors.internal('JSON-RPC notifications must be JSON serializable objects');
+    }
+    await _class_private_method_get(this, _write, write).call(this, {
+        ...requestObject,
+        jsonrpc: '2.0'
+    });
+}
+async function respond(id, requestObject) {
+    if (!isValidJson(requestObject) || !isObject(requestObject)) {
+        // Instead of throwing, we directly respond with an error.
+        // This prevents an issue where we wouldn't respond when errors were non-serializable
+        await _class_private_method_get(this, _write, write).call(this, {
+            error: serializeError(rpcErrors.internal('JSON-RPC responses must be JSON serializable objects.')),
+            id,
+            jsonrpc: '2.0'
+        });
+        return;
+    }
+    await _class_private_method_get(this, _write, write).call(this, {
+        ...requestObject,
+        id,
+        jsonrpc: '2.0'
+    });
+}
 
 //# sourceMappingURL=BaseSnapExecutor.js.map