@metamask/snaps-execution-environments 0.34.1-flask.1 → 0.35.0-flask.1

package/dist/{common → esm/common}/sortParams.js

@@ -1,7 +1,4 @@
-"use strict";
 // original source sortParamKeys from: https://github.com/etclabscore/sig.tools/blob/master/src/postMessageServer/postMessageServer.ts#L75-L77
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortParamKeys = void 0;
 /**
  * Deterministically sort JSON-RPC parameter keys. This makes it possible to
  * support both arrays and objects as parameters. Objects are sorted and turned
@@ -15,21 +12,18 @@ exports.sortParamKeys = void 0;
  * @returns The values for the sorted keys. If `params` is not provided, this
  * returns an empty array. If `params` is an array, this returns the same
  * `params`.
- */
-const sortParamKeys = (methodParams, params) => {
+ */ 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);
+    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);
 };
-exports.sortParamKeys = sortParamKeys;
+
 //# sourceMappingURL=sortParams.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/common/sortParams.ts"],"sourcesContent":["// original source sortParamKeys from: https://github.com/etclabscore/sig.tools/blob/master/src/postMessageServer/postMessageServer.ts#L75-L77\n\nimport { 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

@@ -0,0 +1,120 @@
+import { assert, assertStruct, JsonStruct } from '@metamask/utils';
+import { ethErrors } from 'eth-rpc-errors';
+import { log } from '../logging';
+/**
+ * Takes an error that was thrown, determines if it is
+ * an error object. If it is then it will return that. Otherwise,
+ * an error object is created with the original error message.
+ *
+ * @param originalError - The error that was originally thrown.
+ * @returns An error object.
+ */ export 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;
+}
+/**
+ * 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.
+const BLOCKED_RPC_METHODS = Object.freeze([
+    'eth_requestAccounts',
+    'wallet_requestSnaps',
+    'wallet_requestPermissions'
+]);
+/**
+ * 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_*`.');
+    assert(!BLOCKED_RPC_METHODS.includes(args.method), ethErrors.rpc.methodNotFound({
+        data: {
+            method: args.method
+        }
+    }));
+    assertStruct(args, JsonStruct, 'Provided value is not JSON-RPC compatible');
+}
+/**
+ * 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_'), ethErrors.rpc.methodNotFound({
+        data: {
+            method: args.method
+        }
+    }));
+    assert(!BLOCKED_RPC_METHODS.includes(args.method), ethErrors.rpc.methodNotFound({
+        data: {
+            method: args.method
+        }
+    }));
+    assertStruct(args, JsonStruct, 'Provided value is not JSON-RPC compatible');
+}
+
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/common/utils.ts"],"sourcesContent":["import { StreamProvider } from '@metamask/providers';\nimport { RequestArguments } from '@metamask/providers/dist/BaseProvider';\nimport { assert, assertStruct, JsonStruct } from '@metamask/utils';\nimport { ethErrors } from 'eth-rpc-errors';\n\nimport { log } from '../logging';\n\n/**\n * Takes an error that was thrown, determines if it is\n * an error object. If it is then it will return that. Otherwise,\n * an error object is created with the original error message.\n *\n * @param originalError - The error that was originally thrown.\n * @returns An error object.\n */\nexport function constructError(originalError: unknown) {\n  let _originalError: Error | undefined;\n  if (originalError instanceof Error) {\n    _originalError = originalError;\n  } else if (typeof originalError === 'string') {\n    _originalError = new Error(originalError);\n    // The stack is useless in this case.\n    delete _originalError.stack;\n  }\n  return _originalError;\n}\n\n/**\n * Make proxy for Promise and handle the teardown process properly.\n * If the teardown is called in the meanwhile, Promise result will not be\n * exposed to the snap anymore and warning will be logged to the console.\n *\n * @param originalPromise - Original promise.\n * @param teardownRef - Reference containing teardown count.\n * @param teardownRef.lastTeardown - Number of the last teardown.\n * @returns New proxy promise.\n */\nexport async function withTeardown<T>(\n  originalPromise: Promise<T>,\n  teardownRef: { lastTeardown: number },\n): Promise<T> {\n  const myTeardown = teardownRef.lastTeardown;\n  return new Promise<T>((resolve, reject) => {\n    originalPromise\n      .then((value) => {\n        if (teardownRef.lastTeardown === myTeardown) {\n          resolve(value);\n        } else {\n          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.\nconst BLOCKED_RPC_METHODS = Object.freeze([\n  'eth_requestAccounts',\n  'wallet_requestSnaps',\n  'wallet_requestPermissions',\n]);\n\n/**\n * Asserts the validity of request arguments for a snap outbound request using the `snap.request` API.\n *\n * @param args - The arguments to validate.\n */\nexport function assertSnapOutboundRequest(args: RequestArguments) {\n  // Disallow any non `wallet_` or `snap_` methods for separation of concerns.\n  assert(\n    String.prototype.startsWith.call(args.method, 'wallet_') ||\n      String.prototype.startsWith.call(args.method, 'snap_'),\n    'The global Snap API only allows RPC methods starting with `wallet_*` and `snap_*`.',\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    ethErrors.rpc.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(args, JsonStruct, 'Provided value is not JSON-RPC compatible');\n}\n\n/**\n * Asserts the validity of request arguments for an ethereum outbound request using the `ethereum.request` API.\n *\n * @param args - The arguments to validate.\n */\nexport function assertEthereumOutboundRequest(args: RequestArguments) {\n  // Disallow snaps methods for separation of concerns.\n  assert(\n    !String.prototype.startsWith.call(args.method, 'snap_'),\n    ethErrors.rpc.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    ethErrors.rpc.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(args, JsonStruct, 'Provided value is not JSON-RPC compatible');\n}\n"],"names":["assert","assertStruct","JsonStruct","ethErrors","log","constructError","originalError","_originalError","Error","stack","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","rpc","methodNotFound","data","assertEthereumOutboundRequest"],"mappings":"AAEA,SAASA,MAAM,EAAEC,YAAY,EAAEC,UAAU,QAAQ,kBAAkB;AACnE,SAASC,SAAS,QAAQ,iBAAiB;AAE3C,SAASC,GAAG,QAAQ,aAAa;AAEjC;;;;;;;CAOC,GACD,OAAO,SAASC,eAAeC,aAAsB;IACnD,IAAIC;IACJ,IAAID,yBAAyBE,OAAO;QAClCD,iBAAiBD;IACnB,OAAO,IAAI,OAAOA,kBAAkB,UAAU;QAC5CC,iBAAiB,IAAIC,MAAMF;QAC3B,qCAAqC;QACrC,OAAOC,eAAeE,KAAK;IAC7B;IACA,OAAOF;AACT;AAEA;;;;;;;;;CASC,GACD,OAAO,eAAeG,aACpBC,eAA2B,EAC3BC,WAAqC;IAErC,MAAMC,aAAaD,YAAYE,YAAY;IAC3C,OAAO,IAAIC,QAAW,CAACC,SAASC;QAC9BN,gBACGO,IAAI,CAAC,CAACC;YACL,IAAIP,YAAYE,YAAY,KAAKD,YAAY;gBAC3CG,QAAQG;YACV,OAAO;gBACLf,IACE;YAEJ;QACF,GACCgB,KAAK,CAAC,CAACC;YACN,IAAIT,YAAYE,YAAY,KAAKD,YAAY;gBAC3CI,OAAOI;YACT,OAAO;gBACLjB,IACE;YAEJ;QACF;IACJ;AACF;AAEA;;;;;;;CAOC,GACD,OAAO,SAASkB,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,MAAMQ,sBAAsBC,OAAOC,MAAM,CAAC;IACxC;IACA;IACA;CACD;AAED;;;;CAIC,GACD,OAAO,SAASC,0BAA0BC,IAAsB;IAC9D,4EAA4E;IAC5ErC,OACEsC,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACJ,KAAKK,MAAM,EAAE,cAC5CJ,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACJ,KAAKK,MAAM,EAAE,UAChD;IAEF1C,OACE,CAACiC,oBAAoBH,QAAQ,CAACO,KAAKK,MAAM,GACzCvC,UAAUwC,GAAG,CAACC,cAAc,CAAC;QAC3BC,MAAM;YACJH,QAAQL,KAAKK,MAAM;QACrB;IACF;IAEFzC,aAAaoC,MAAMnC,YAAY;AACjC;AAEA;;;;CAIC,GACD,OAAO,SAAS4C,8BAA8BT,IAAsB;IAClE,qDAAqD;IACrDrC,OACE,CAACsC,OAAOC,SAAS,CAACC,UAAU,CAACC,IAAI,CAACJ,KAAKK,MAAM,EAAE,UAC/CvC,UAAUwC,GAAG,CAACC,cAAc,CAAC;QAC3BC,MAAM;YACJH,QAAQL,KAAKK,MAAM;QACrB;IACF;IAEF1C,OACE,CAACiC,oBAAoBH,QAAQ,CAACO,KAAKK,MAAM,GACzCvC,UAAUwC,GAAG,CAACC,cAAc,CAAC;QAC3BC,MAAM;YACJH,QAAQL,KAAKK,MAAM;QACrB;IACF;IAEFzC,aAAaoC,MAAMnC,YAAY;AACjC"}

package/dist/esm/common/validation.js

@@ -0,0 +1,92 @@
+import { ChainIdStruct, HandlerType } from '@metamask/snaps-utils';
+import { assertStruct, JsonRpcIdStruct, JsonRpcRequestStruct, JsonRpcSuccessStruct, JsonStruct } from '@metamask/utils';
+import { array, assign, enums, is, literal, nullable, object, omit, optional, record, string, tuple, union } from 'superstruct';
+const VALIDATION_FUNCTIONS = {
+    [HandlerType.OnRpcRequest]: validateFunctionExport,
+    [HandlerType.OnTransaction]: validateFunctionExport,
+    [HandlerType.OnCronjob]: validateFunctionExport
+};
+/**
+ * Validates a function export.
+ *
+ * @param snapExport - The export itself.
+ * @returns True if the export matches the expected shape, false otherwise.
+ */ function validateFunctionExport(snapExport) {
+    return typeof snapExport === 'function';
+}
+/**
+ * Validates a given snap export.
+ *
+ * @param type - The type of export expected.
+ * @param snapExport - The export itself.
+ * @returns True if the export matches the expected shape, false otherwise.
+ */ export function validateExport(type, snapExport) {
+    const validationFunction = VALIDATION_FUNCTIONS[type];
+    return validationFunction?.(snapExport) ?? false;
+}
+export const JsonRpcRequestWithoutIdStruct = assign(omit(JsonRpcRequestStruct, [
+    'id'
+]), object({
+    id: optional(JsonRpcIdStruct)
+}));
+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(),
+    optional(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');
+}
+const OkResponseStruct = assign(JsonRpcSuccessStruct, object({
+    result: OkStruct
+}));
+const SnapRpcResponse = JsonRpcSuccessStruct;
+
+//# sourceMappingURL=validation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/common/validation.ts"],"sourcesContent":["import { ChainIdStruct, HandlerType } from '@metamask/snaps-utils';\nimport {\n  assertStruct,\n  Json,\n  JsonRpcIdStruct,\n  JsonRpcRequestStruct,\n  JsonRpcSuccess,\n  JsonRpcSuccessStruct,\n  JsonStruct,\n} from '@metamask/utils';\nimport {\n  array,\n  assign,\n  enums,\n  Infer,\n  is,\n  literal,\n  nullable,\n  object,\n  omit,\n  optional,\n  record,\n  string,\n  tuple,\n  union,\n} from 'superstruct';\n\nconst VALIDATION_FUNCTIONS = {\n  [HandlerType.OnRpcRequest]: validateFunctionExport,\n  [HandlerType.OnTransaction]: validateFunctionExport,\n  [HandlerType.OnCronjob]: validateFunctionExport,\n};\n\n/**\n * Validates a function export.\n *\n * @param snapExport - The export itself.\n * @returns True if the export matches the expected shape, false otherwise.\n */\nfunction validateFunctionExport(\n  snapExport: unknown,\n): snapExport is (...args: unknown[]) => unknown {\n  return typeof snapExport === 'function';\n}\n\n/**\n * Validates a given snap export.\n *\n * @param type - The type of export expected.\n * @param snapExport - The export itself.\n * @returns True if the export matches the expected shape, false otherwise.\n */\nexport function validateExport(type: HandlerType, snapExport: unknown) {\n  const validationFunction = VALIDATION_FUNCTIONS[type];\n  return validationFunction?.(snapExport) ?? false;\n}\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 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":["ChainIdStruct","HandlerType","assertStruct","JsonRpcIdStruct","JsonRpcRequestStruct","JsonRpcSuccessStruct","JsonStruct","array","assign","enums","is","literal","nullable","object","omit","optional","record","string","tuple","union","VALIDATION_FUNCTIONS","OnRpcRequest","validateFunctionExport","OnTransaction","OnCronjob","snapExport","validateExport","type","validationFunction","JsonRpcRequestWithoutIdStruct","id","EndowmentStruct","isEndowment","value","isEndowmentsArray","Array","isArray","every","OkStruct","PingRequestArgumentsStruct","undefined","TerminateRequestArgumentsStruct","ExecuteSnapRequestArgumentsStruct","SnapRpcRequestArgumentsStruct","Object","values","params","OnTransactionRequestArgumentsStruct","transaction","chainId","transactionOrigin","assertIsOnTransactionRequestArguments","OkResponseStruct","result","SnapRpcResponse"],"mappings":"AAAA,SAASA,aAAa,EAAEC,WAAW,QAAQ,wBAAwB;AACnE,SACEC,YAAY,EAEZC,eAAe,EACfC,oBAAoB,EAEpBC,oBAAoB,EACpBC,UAAU,QACL,kBAAkB;AACzB,SACEC,KAAK,EACLC,MAAM,EACNC,KAAK,EAELC,EAAE,EACFC,OAAO,EACPC,QAAQ,EACRC,MAAM,EACNC,IAAI,EACJC,QAAQ,EACRC,MAAM,EACNC,MAAM,EACNC,KAAK,EACLC,KAAK,QACA,cAAc;AAErB,MAAMC,uBAAuB;IAC3B,CAACnB,YAAYoB,YAAY,CAAC,EAAEC;IAC5B,CAACrB,YAAYsB,aAAa,CAAC,EAAED;IAC7B,CAACrB,YAAYuB,SAAS,CAAC,EAAEF;AAC3B;AAEA;;;;;CAKC,GACD,SAASA,uBACPG,UAAmB;IAEnB,OAAO,OAAOA,eAAe;AAC/B;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,eAAeC,IAAiB,EAAEF,UAAmB;IACnE,MAAMG,qBAAqBR,oBAAoB,CAACO,KAAK;IACrD,OAAOC,qBAAqBH,eAAe;AAC7C;AAEA,OAAO,MAAMI,gCAAgCrB,OAC3CM,KAAKV,sBAAsB;IAAC;CAAK,GACjCS,OAAO;IACLiB,IAAIf,SAASZ;AACf,IACA;AAMF,OAAO,MAAM4B,kBAAkBd,SAAS;AAGxC;;;;;CAKC,GACD,OAAO,SAASe,YAAYC,KAAc;IACxC,OAAOvB,GAAGuB,OAAOF;AACnB;AAEA;;;;;CAKC,GACD,OAAO,SAASG,kBAAkBD,KAAc;IAC9C,OAAOE,MAAMC,OAAO,CAACH,UAAUA,MAAMI,KAAK,CAACL;AAC7C;AAEA,MAAMM,WAAW3B,QAAQ;AAEzB,OAAO,MAAM4B,6BAA6BxB,SACxCI,MAAM;IAACR,QAAQ6B;IAAYjC;CAAQ,GACnC;AAEF,OAAO,MAAMkC,kCAAkCtB,MAAM;IACnDR,QAAQ6B;IACRjC;CACD,EAAE;AAEH,OAAO,MAAMmC,oCAAoCxB,MAAM;IACrDD;IACAA;IACAF,SAASR,MAAMwB;CAChB,EAAE;AAEH,OAAO,MAAMY,gCAAgCzB,MAAM;IACjDD;IACAR,MAAMmC,OAAOC,MAAM,CAAC5C;IACpBgB;IACAT,OACEqB,+BACAhB,OAAO;QACLiC,QAAQ/B,SAASC,OAAOC,UAAUX;IACpC;CAEH,EAAE;AAqBH,OAAO,MAAMyC,sCAAsClC,OAAO;IACxD,oCAAoC;IACpCmC,aAAahC,OAAOC,UAAUX;IAC9B2C,SAASjD;IACTkD,mBAAmBtC,SAASK;AAC9B,GAAG;AAMH;;;;;;;CAOC,GACD,OAAO,SAASkC,sCACdlB,KAAc;IAEd/B,aACE+B,OACAc,qCACA;AAEJ;AAEA,MAAMK,mBAAmB5C,OACvBH,sBACAQ,OAAO;IACLwC,QAAQf;AACV;AAGF,MAAMgB,kBAAkBjD"}

package/dist/esm/iframe/IFrameSnapExecutor.js

@@ -0,0 +1,35 @@
+import ObjectMultiplex from '@metamask/object-multiplex';
+import { WindowPostMessageStream } from '@metamask/post-message-stream';
+import { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';
+import pump from 'pump';
+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();
+        pump(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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/iframe/IFrameSnapExecutor.ts"],"sourcesContent":["import ObjectMultiplex from '@metamask/object-multiplex';\nimport {\n  BasePostMessageStream,\n  WindowPostMessageStream,\n} from '@metamask/post-message-stream';\nimport { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';\nimport pump from 'pump';\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    pump(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","pump","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;AACzD,SAEEC,uBAAuB,QAClB,gCAAgC;AACvC,SAASC,QAAQ,EAAEC,iBAAiB,QAAQ,wBAAwB;AACpE,OAAOC,UAAU,OAAO;AAExB,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,KAAKK,QAAQO,KAAKP,QAAQ,CAACQ;YACzB,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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/iframe/index.ts"],"sourcesContent":["import { executeLockdownEvents } from '../common/lockdown/lockdown-events';\nimport { executeLockdownMore } from '../common/lockdown/lockdown-more';\nimport { IFrameSnapExecutor } from './IFrameSnapExecutor';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\nexecuteLockdownEvents();\n\nIFrameSnapExecutor.initialize();\n"],"names":["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/logging.js

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging.ts"],"sourcesContent":["import { snapsLogger } from '@metamask/snaps-utils';\nimport { createModuleLogger } from '@metamask/utils';\n\n/**\n * A logging function specific to this package. The log messages don't show up\n * by default, but they can be enabled by setting the environment variable:\n * - `DEBUG=metamask:snaps:snaps-execution-environments`, or\n * - `DEBUG=metamask:snaps:*` to enable all logs from `@metamask/snaps-*`.\n */\nexport const log = createModuleLogger(\n  snapsLogger,\n  'snaps-execution-environments',\n);\n"],"names":["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

@@ -0,0 +1,24 @@
+import ObjectMultiplex from '@metamask/object-multiplex';
+import { ProcessMessageStream } from '@metamask/post-message-stream';
+import { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';
+import pump from 'pump';
+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();
+        pump(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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/node-process/ChildProcessSnapExecutor.ts"],"sourcesContent":["import ObjectMultiplex from '@metamask/object-multiplex';\nimport { ProcessMessageStream } from '@metamask/post-message-stream';\nimport { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';\nimport pump from 'pump';\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    pump(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","pump","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,OAAOC,UAAU,OAAO;AAExB,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,KAAKK,cAAcC,KAAYD,cAAc,CAACE;YAC5C,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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/node-process/index.ts"],"sourcesContent":["import { executeLockdownMore } from '../common/lockdown/lockdown-more';\nimport { ChildProcessSnapExecutor } from './ChildProcessSnapExecutor';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\n\nChildProcessSnapExecutor.initialize();\n"],"names":["executeLockdownMore","ChildProcessSnapExecutor","initialize"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,mCAAmC;AACvE,SAASC,wBAAwB,QAAQ,6BAA6B;AAEtE,0CAA0C;AAC1CD;AAEAC,yBAAyBC,UAAU"}

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

@@ -0,0 +1,24 @@
+import ObjectMultiplex from '@metamask/object-multiplex';
+import { ThreadMessageStream } from '@metamask/post-message-stream';
+import { logError, SNAP_STREAM_NAMES } from '@metamask/snaps-utils';
+import pump from 'pump';
+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();
+        pump(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

@@ -0,0 +1 @@
+{"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 pump from 'pump';\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    pump(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","pump","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,OAAOC,UAAU,OAAO;AAExB,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,KAAKK,cAAcC,KAAYD,cAAc,CAACE;YAC5C,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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/node-thread/index.ts"],"sourcesContent":["import { executeLockdownMore } from '../common/lockdown/lockdown-more';\nimport { ThreadSnapExecutor } from './ThreadSnapExecutor';\n\n// Lockdown is already applied in LavaMoat\nexecuteLockdownMore();\n\nThreadSnapExecutor.initialize();\n"],"names":["executeLockdownMore","ThreadSnapExecutor","initialize"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,mCAAmC;AACvE,SAASC,kBAAkB,QAAQ,uBAAuB;AAE1D,0CAA0C;AAC1CD;AAEAC,mBAAmBC,UAAU"}

package/dist/esm/offscreen/OffscreenSnapExecutor.js

@@ -0,0 +1,176 @@
+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_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+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, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { WindowPostMessageStream } from '@metamask/post-message-stream';
+import { createWindow, logError } from '@metamask/snaps-utils';
+import { assert } from '@metamask/utils';
+var _stream = /*#__PURE__*/ new WeakMap(), /**
+   * Handle an incoming message from the `OffscreenExecutionService`. This
+   * assumes that the message contains a `jobId` property, and a JSON-RPC
+   * request in the `data` property.
+   *
+   * @param data - The message data.
+   * @param data.data - The JSON-RPC request.
+   * @param data.jobId - The job ID.
+   * @param data.extra - Extra data.
+   * @param data.extra.frameUrl - The URL to load in the iframe.
+   */ _onData = /*#__PURE__*/ new WeakSet(), _initializeJob = /*#__PURE__*/ new WeakSet(), /**
+   * Terminate the job with the given ID. This will close the iframe and delete
+   * the job from the internal job map.
+   *
+   * @param jobId - The job ID.
+   */ _terminateJob = /*#__PURE__*/ new WeakSet();
+/**
+ * A snap executor using the Offscreen Documents API.
+ *
+ * This is not a traditional snap executor, as it does not execute snaps itself.
+ * Instead, it creates an iframe window for each snap execution, and sends the
+ * snap execution request to the iframe window. The iframe window is responsible
+ * for executing the snap.
+ *
+ * Extensions can only have a single offscreen document, so this executor is
+ * persisted between snap executions. The offscreen snap executor essentially
+ * acts as a proxy between the extension and the iframe execution environment.
+ *
+ * @see https://developer.chrome.com/docs/extensions/reference/offscreen/
+ */ export class OffscreenSnapExecutor {
+    /**
+   * Initialize the executor with the given stream. This is a wrapper around the
+   * constructor.
+   *
+   * @param stream - The stream to use for communication.
+   * @returns The initialized executor.
+   */ static initialize(stream) {
+        return new OffscreenSnapExecutor(stream);
+    }
+    constructor(stream){
+        _class_private_method_init(this, _onData);
+        /**
+   * Create a new iframe and set up a stream to communicate with it.
+   *
+   * @param jobId - The job ID.
+   * @param frameUrl - The URL to load in the iframe.
+   */ _class_private_method_init(this, _initializeJob);
+        _class_private_method_init(this, _terminateJob);
+        _class_private_field_init(this, _stream, {
+            writable: true,
+            value: void 0
+        });
+        _define_property(this, "jobs", {});
+        _class_private_field_set(this, _stream, stream);
+        _class_private_field_get(this, _stream).on('data', _class_private_method_get(this, _onData, onData).bind(this));
+    }
+}
+function onData(data) {
+    const { jobId, extra: { frameUrl }, data: request } = data;
+    if (!this.jobs[jobId]) {
+        // This ensures that a job is initialized before it is used. To avoid
+        // code duplication, we call the `#onData` method again, which will
+        // run the rest of the logic after initialization.
+        _class_private_method_get(this, _initializeJob, initializeJob).call(this, jobId, frameUrl).then(()=>{
+            _class_private_method_get(this, _onData, onData).call(this, data);
+        }).catch((error)=>{
+            logError('[Worker] Error initializing job:', error);
+        });
+        return;
+    }
+    // This is a method specific to the `OffscreenSnapExecutor`, as the service
+    // itself does not have access to the iframes directly.
+    if (request.method === 'terminateJob') {
+        _class_private_method_get(this, _terminateJob, terminateJob).call(this, jobId);
+        return;
+    }
+    this.jobs[jobId].stream.write(request);
+}
+async function initializeJob(jobId, frameUrl) {
+    const window = await createWindow(frameUrl, jobId);
+    const jobStream = new WindowPostMessageStream({
+        name: 'parent',
+        target: 'child',
+        targetWindow: window,
+        targetOrigin: '*'
+    });
+    // Write messages from the iframe to the parent, wrapped with the job ID.
+    jobStream.on('data', (data)=>{
+        _class_private_field_get(this, _stream).write({
+            data,
+            jobId
+        });
+    });
+    this.jobs[jobId] = {
+        id: jobId,
+        window,
+        stream: jobStream
+    };
+    return this.jobs[jobId];
+}
+function terminateJob(jobId) {
+    assert(this.jobs[jobId], `Job "${jobId}" not found.`);
+    const iframe = document.getElementById(jobId);
+    assert(iframe, `Iframe with ID "${jobId}" not found.`);
+    iframe.remove();
+    this.jobs[jobId].stream.destroy();
+    delete this.jobs[jobId];
+}
+
+//# sourceMappingURL=OffscreenSnapExecutor.js.map