@metamask/snaps-execution-environments 4.0.0 → 5.0.0

package/dist/esm/common/BaseSnapExecutor.js

@@ -1,486 +0,0 @@
-// 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, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { createIdRemapMiddleware } from '@metamask/json-rpc-engine';
-import { StreamProvider } from '@metamask/providers/dist/StreamProvider';
-import { errorCodes, rpcErrors, serializeError } from '@metamask/rpc-errors';
-import { getErrorData } from '@metamask/snaps-sdk';
-import { SNAP_EXPORT_NAMES, logError, SNAP_EXPORTS, WrappedSnapError, unwrapError, logInfo } from '@metamask/snaps-utils';
-import { isObject, isValidJson, assert, isJsonRpcRequest, hasProperty, getSafeJson, JsonRpcIdStruct } from '@metamask/utils';
-import { validate, is } 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, 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
- * parameters, if they are an object.
- */ const EXECUTION_ENVIRONMENT_METHODS = {
-    ping: {
-        struct: PingRequestArgumentsStruct,
-        params: []
-    },
-    executeSnap: {
-        struct: ExecuteSnapRequestArgumentsStruct,
-        params: [
-            'snapId',
-            'sourceCode',
-            'endowments'
-        ]
-    },
-    terminate: {
-        struct: TerminateRequestArgumentsStruct,
-        params: []
-    },
-    snapRpc: {
-        struct: SnapRpcRequestArgumentsStruct,
-        params: [
-            'target',
-            'handler',
-            'origin',
-            'request'
-        ]
-    }
-};
-var _write = /*#__PURE__*/ new WeakSet(), _notify = /*#__PURE__*/ new WeakSet(), _respond = /*#__PURE__*/ new WeakSet();
-export class BaseSnapExecutor {
-    errorHandler(error, data) {
-        const serializedError = serializeError(error, {
-            fallbackError: unhandledError,
-            shouldIncludeStack: false
-        });
-        const errorData = getErrorData(serializedError);
-        _class_private_method_get(this, _notify, notify).call(this, {
-            method: 'UnhandledError',
-            params: {
-                error: {
-                    ...serializedError,
-                    data: {
-                        ...errorData,
-                        ...data
-                    }
-                }
-            }
-        }).catch((notifyError)=>{
-            logError(notifyError);
-        });
-    }
-    async onCommandRequest(message) {
-        if (!isJsonRpcRequest(message)) {
-            if (hasProperty(message, 'id') && is(message.id, JsonRpcIdStruct)) {
-                // Instead of throwing, we directly respond with an error.
-                // We can only do this if the message ID is still valid.
-                await _class_private_method_get(this, _write, write).call(this, {
-                    error: serializeError(rpcErrors.internal('JSON-RPC requests must be JSON serializable objects.')),
-                    id: message.id,
-                    jsonrpc: '2.0'
-                });
-            } else {
-                logInfo('Command stream received a non-JSON-RPC request, and was unable to respond.');
-            }
-            return;
-        }
-        const { id, method, params } = message;
-        if (!hasProperty(EXECUTION_ENVIRONMENT_METHODS, method)) {
-            await _class_private_method_get(this, _respond, respond).call(this, id, {
-                error: rpcErrors.methodNotFound({
-                    data: {
-                        method
-                    }
-                }).serialize()
-            });
-            return;
-        }
-        const methodObject = EXECUTION_ENVIRONMENT_METHODS[method];
-        // support params by-name and by-position
-        const paramsAsArray = sortParamKeys(methodObject.params, params);
-        const [error] = validate(paramsAsArray, methodObject.struct);
-        if (error) {
-            await _class_private_method_get(this, _respond, respond).call(this, id, {
-                error: rpcErrors.invalidParams({
-                    message: `Invalid parameters for method "${method}": ${error.message}.`,
-                    data: {
-                        method,
-                        params: paramsAsArray
-                    }
-                }).serialize()
-            });
-            return;
-        }
-        try {
-            const result = await this.methods[method](...paramsAsArray);
-            await _class_private_method_get(this, _respond, respond).call(this, id, {
-                result
-            });
-        } catch (rpcError) {
-            await _class_private_method_get(this, _respond, respond).call(this, id, {
-                error: serializeError(rpcError, {
-                    fallbackError
-                })
-            });
-        }
-    }
-    /**
-   * Attempts to evaluate a snap in SES. Generates APIs for the snap. May throw
-   * on errors.
-   *
-   * @param snapId - The id of the snap.
-   * @param sourceCode - The source code of the snap, in IIFE format.
-   * @param _endowments - An array of the names of the endowments.
-   */ async startSnap(snapId, sourceCode, _endowments) {
-        log(`Starting snap '${snapId}' in worker.`);
-        if (this.snapPromiseErrorHandler) {
-            removeEventListener('unhandledrejection', this.snapPromiseErrorHandler);
-        }
-        if (this.snapErrorHandler) {
-            removeEventListener('error', this.snapErrorHandler);
-        }
-        this.snapErrorHandler = (error)=>{
-            this.errorHandler(error.error, {
-                snapId
-            });
-        };
-        this.snapPromiseErrorHandler = (error)=>{
-            this.errorHandler(error instanceof Error ? error : error.reason, {
-                snapId
-            });
-        };
-        const provider = new StreamProvider(this.rpcStream, {
-            jsonRpcStreamName: 'metamask-provider',
-            rpcMiddleware: [
-                createIdRemapMiddleware()
-            ]
-        });
-        await provider.initialize();
-        const snap = this.createSnapGlobal(provider);
-        const ethereum = this.createEIP1193Provider(provider);
-        // We specifically use any type because the Snap can modify the object any way they want
-        const snapModule = {
-            exports: {}
-        };
-        try {
-            const { endowments, teardown: endowmentTeardown } = createEndowments({
-                snap,
-                ethereum,
-                snapId,
-                endowments: _endowments,
-                notify: _class_private_method_get(this, _notify, notify).bind(this)
-            });
-            // !!! Ensure that this is the only place the data is being set.
-            // Other methods access the object value and mutate its properties.
-            this.snapData.set(snapId, {
-                idleTeardown: endowmentTeardown,
-                runningEvaluations: new Set(),
-                exports: {}
-            });
-            addEventListener('unhandledRejection', this.snapPromiseErrorHandler);
-            addEventListener('error', this.snapErrorHandler);
-            const compartment = new Compartment({
-                ...endowments,
-                module: snapModule,
-                exports: snapModule.exports
-            });
-            // All of those are JavaScript runtime specific and self referential,
-            // but we add them for compatibility sake with external libraries.
-            //
-            // We can't do that in the injected globals object above
-            // because SES creates its own globalThis
-            compartment.globalThis.self = compartment.globalThis;
-            compartment.globalThis.global = compartment.globalThis;
-            compartment.globalThis.window = compartment.globalThis;
-            await this.executeInSnapContext(snapId, ()=>{
-                compartment.evaluate(sourceCode);
-                this.registerSnapExports(snapId, snapModule);
-            });
-        } catch (error) {
-            this.removeSnap(snapId);
-            const [cause] = unwrapError(error);
-            throw rpcErrors.internal({
-                message: `Error while running snap '${snapId}': ${cause.message}`,
-                data: {
-                    cause: cause.serialize()
-                }
-            });
-        }
-    }
-    /**
-   * Cancels all running evaluations of all snaps and clears all snap data.
-   * NOTE:** Should only be called in response to the `terminate` RPC command.
-   */ onTerminate() {
-        // `stop()` tears down snap endowments.
-        // Teardown will also be run for each snap as soon as there are
-        // no more running evaluations for that snap.
-        this.snapData.forEach((data)=>data.runningEvaluations.forEach((evaluation)=>evaluation.stop()));
-        this.snapData.clear();
-    }
-    registerSnapExports(snapId, snapModule) {
-        const data = this.snapData.get(snapId);
-        // Somebody deleted the snap before we could register.
-        if (!data) {
-            return;
-        }
-        data.exports = SNAP_EXPORT_NAMES.reduce((acc, exportName)=>{
-            const snapExport = snapModule.exports[exportName];
-            const { validator } = SNAP_EXPORTS[exportName];
-            if (validator(snapExport)) {
-                return {
-                    ...acc,
-                    [exportName]: snapExport
-                };
-            }
-            return acc;
-        }, {});
-    }
-    /**
-   * Instantiates a snap API object (i.e. `globalThis.snap`).
-   *
-   * @param provider - A StreamProvider connected to MetaMask.
-   * @returns The snap provider object.
-   */ createSnapGlobal(provider) {
-        const originalRequest = provider.request.bind(provider);
-        const request = async (args)=>{
-            const sanitizedArgs = sanitizeRequestArguments(args);
-            assertSnapOutboundRequest(sanitizedArgs);
-            return await withTeardown((async ()=>{
-                await _class_private_method_get(this, _notify, notify).call(this, {
-                    method: 'OutboundRequest',
-                    params: {
-                        source: 'snap.request'
-                    }
-                });
-                try {
-                    return await originalRequest(sanitizedArgs);
-                } finally{
-                    await _class_private_method_get(this, _notify, notify).call(this, {
-                        method: 'OutboundResponse',
-                        params: {
-                            source: 'snap.request'
-                        }
-                    });
-                }
-            })(), this);
-        };
-        // Proxy target is intentionally set to be an empty object, to ensure
-        // that access to the prototype chain is not possible.
-        const snapGlobalProxy = new Proxy({}, {
-            has (_target, prop) {
-                return typeof prop === 'string' && [
-                    'request'
-                ].includes(prop);
-            },
-            get (_target, prop) {
-                if (prop === 'request') {
-                    return request;
-                }
-                return undefined;
-            }
-        });
-        return harden(snapGlobalProxy);
-    }
-    /**
-   * Instantiates an EIP-1193 Ethereum provider object (i.e. `globalThis.ethereum`).
-   *
-   * @param provider - A StreamProvider connected to MetaMask.
-   * @returns The EIP-1193 Ethereum provider object.
-   */ createEIP1193Provider(provider) {
-        const originalRequest = provider.request.bind(provider);
-        const request = async (args)=>{
-            const sanitizedArgs = sanitizeRequestArguments(args);
-            assertEthereumOutboundRequest(sanitizedArgs);
-            return await withTeardown((async ()=>{
-                await _class_private_method_get(this, _notify, notify).call(this, {
-                    method: 'OutboundRequest',
-                    params: {
-                        source: 'ethereum.request'
-                    }
-                });
-                try {
-                    return await originalRequest(sanitizedArgs);
-                } finally{
-                    await _class_private_method_get(this, _notify, notify).call(this, {
-                        method: 'OutboundResponse',
-                        params: {
-                            source: 'ethereum.request'
-                        }
-                    });
-                }
-            })(), this);
-        };
-        const streamProviderProxy = proxyStreamProvider(provider, request);
-        return harden(streamProviderProxy);
-    }
-    /**
-   * Removes the snap with the given name.
-   *
-   * @param snapId - The id of the snap to remove.
-   */ removeSnap(snapId) {
-        this.snapData.delete(snapId);
-    }
-    /**
-   * Calls the specified executor function in the context of the specified snap.
-   * Essentially, this means that the operation performed by the executor is
-   * counted as an evaluation of the specified snap. When the count of running
-   * evaluations of a snap reaches zero, its endowments are torn down.
-   *
-   * @param snapId - The id of the snap whose context to execute in.
-   * @param executor - The function that will be executed in the snap's context.
-   * @returns The executor's return value.
-   * @template Result - The return value of the executor.
-   */ async executeInSnapContext(snapId, executor) {
-        const data = this.snapData.get(snapId);
-        if (data === undefined) {
-            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.
-                rpcErrors.internal(`The snap "${snapId}" has been terminated during execution.`)));
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const evaluationData = {
-            stop: stop
-        };
-        try {
-            data.runningEvaluations.add(evaluationData);
-            // Notice that we have to await this executor.
-            // If we didn't, we would decrease the amount of running evaluations
-            // before the promise actually resolves
-            return await Promise.race([
-                executor(),
-                stopPromise
-            ]);
-        } catch (error) {
-            throw new WrappedSnapError(error);
-        } finally{
-            data.runningEvaluations.delete(evaluationData);
-            if (data.runningEvaluations.size === 0) {
-                this.lastTeardown += 1;
-                await data.idleTeardown();
-            }
-        }
-    }
-    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);
-        _define_property(this, "methods", void 0);
-        _define_property(this, "snapErrorHandler", void 0);
-        _define_property(this, "snapPromiseErrorHandler", void 0);
-        _define_property(this, "lastTeardown", 0);
-        this.snapData = new Map();
-        this.commandStream = commandStream;
-        this.commandStream.on('data', (data)=>{
-            this.onCommandRequest(data).catch((error)=>{
-                // TODO: Decide how to handle errors.
-                logError(error);
-            });
-        });
-        this.rpcStream = rpcStream;
-        this.methods = getCommandMethodImplementations(this.startSnap.bind(this), async (target, handlerType, args)=>{
-            const data = this.snapData.get(target);
-            // We're capturing the handler in case someone modifies the data object
-            // before the call.
-            const handler = data?.exports[handlerType];
-            const { required } = SNAP_EXPORTS[handlerType];
-            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;
-            }
-            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;
-            }
-            // /!\ Always return only sanitized JSON to prevent security flaws. /!\
-            try {
-                return getSafeJson(result);
-            } catch (error) {
-                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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/common/BaseSnapExecutor.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/triple-slash-reference, spaced-comment\n/// <reference path=\"../../../../node_modules/ses/types.d.ts\" />\nimport { createIdRemapMiddleware } from '@metamask/json-rpc-engine';\nimport type { RequestArguments } from '@metamask/providers/dist/BaseProvider';\nimport { StreamProvider } from '@metamask/providers/dist/StreamProvider';\nimport { errorCodes, rpcErrors, serializeError } from '@metamask/rpc-errors';\nimport type { SnapsProvider } from '@metamask/snaps-sdk';\nimport { getErrorData } from '@metamask/snaps-sdk';\nimport type {\n  SnapExports,\n  HandlerType,\n  SnapExportsParameters,\n} from '@metamask/snaps-utils';\nimport {\n  SNAP_EXPORT_NAMES,\n  logError,\n  SNAP_EXPORTS,\n  WrappedSnapError,\n  unwrapError,\n  logInfo,\n} from '@metamask/snaps-utils';\nimport type {\n  JsonRpcNotification,\n  JsonRpcId,\n  JsonRpcRequest,\n  Json,\n} from '@metamask/utils';\nimport {\n  isObject,\n  isValidJson,\n  assert,\n  isJsonRpcRequest,\n  hasProperty,\n  getSafeJson,\n  JsonRpcIdStruct,\n} from '@metamask/utils';\nimport type { Duplex } from 'readable-stream';\nimport { validate, is } from 'superstruct';\n\nimport { log } from '../logging';\nimport type { CommandMethodsMapping } from './commands';\nimport { getCommandMethodImplementations } from './commands';\nimport { createEndowments } from './endowments';\nimport { addEventListener, removeEventListener } from './globalEvents';\nimport { sortParamKeys } from './sortParams';\nimport {\n  assertEthereumOutboundRequest,\n  assertSnapOutboundRequest,\n  sanitizeRequestArguments,\n  proxyStreamProvider,\n  withTeardown,\n} from './utils';\nimport {\n  ExecuteSnapRequestArgumentsStruct,\n  PingRequestArgumentsStruct,\n  SnapRpcRequestArgumentsStruct,\n  TerminateRequestArgumentsStruct,\n} from './validation';\n\ntype EvaluationData = {\n  stop: () => void;\n};\n\ntype SnapData = {\n  exports: SnapExports;\n  runningEvaluations: Set<EvaluationData>;\n  idleTeardown: () => Promise<void>;\n};\n\nconst fallbackError = {\n  code: errorCodes.rpc.internal,\n  message: 'Execution Environment Error',\n};\n\nconst unhandledError = rpcErrors\n  .internal<Json>({\n    message: 'Unhandled Snap Error',\n  })\n  .serialize();\n\nexport type InvokeSnapArgs = Omit<SnapExportsParameters[0], 'chainId'>;\n\nexport type InvokeSnap = (\n  target: string,\n  handler: HandlerType,\n  args: InvokeSnapArgs | undefined,\n) => Promise<Json>;\n\n/**\n * The supported methods in the execution environment. The validator checks the\n * incoming JSON-RPC request, and the `params` property is used for sorting the\n * parameters, if they are an object.\n */\nconst EXECUTION_ENVIRONMENT_METHODS = {\n  ping: {\n    struct: PingRequestArgumentsStruct,\n    params: [],\n  },\n  executeSnap: {\n    struct: ExecuteSnapRequestArgumentsStruct,\n    params: ['snapId', 'sourceCode', 'endowments'],\n  },\n  terminate: {\n    struct: TerminateRequestArgumentsStruct,\n    params: [],\n  },\n  snapRpc: {\n    struct: SnapRpcRequestArgumentsStruct,\n    params: ['target', 'handler', 'origin', 'request'],\n  },\n};\n\ntype Methods = typeof EXECUTION_ENVIRONMENT_METHODS;\n\nexport type NotifyFunction = (\n  notification: Omit<JsonRpcNotification, 'jsonrpc'>,\n) => Promise<void>;\n\nexport class BaseSnapExecutor {\n  private readonly snapData: Map<string, SnapData>;\n\n  private readonly commandStream: Duplex;\n\n  private readonly rpcStream: Duplex;\n\n  private readonly methods: CommandMethodsMapping;\n\n  private snapErrorHandler?: (event: ErrorEvent) => void;\n\n  private snapPromiseErrorHandler?: (event: PromiseRejectionEvent) => void;\n\n  private lastTeardown = 0;\n\n  protected constructor(commandStream: Duplex, rpcStream: Duplex) {\n    this.snapData = new Map();\n    this.commandStream = commandStream;\n    this.commandStream.on('data', (data) => {\n      this.onCommandRequest(data).catch((error) => {\n        // TODO: Decide how to handle errors.\n        logError(error);\n      });\n    });\n    this.rpcStream = rpcStream;\n\n    this.methods = getCommandMethodImplementations(\n      this.startSnap.bind(this),\n      async (target, handlerType, args) => {\n        const data = this.snapData.get(target);\n        // We're capturing the handler in case someone modifies the data object\n        // before the call.\n        const handler = data?.exports[handlerType];\n        const { required } = SNAP_EXPORTS[handlerType];\n\n        assert(\n          !required || handler !== undefined,\n          `No ${handlerType} handler exported for snap \"${target}`,\n          rpcErrors.methodNotSupported,\n        );\n\n        // Certain handlers are not required. If they are not exported, we\n        // return null.\n        if (!handler) {\n          return null;\n        }\n\n        let result = await this.executeInSnapContext(target, () =>\n          // TODO: fix handler args type cast\n          handler(args as any),\n        );\n\n        // The handler might not return anything, but undefined is not valid JSON.\n        if (result === undefined) {\n          result = null;\n        }\n\n        // /!\\ Always return only sanitized JSON to prevent security flaws. /!\\\n        try {\n          return getSafeJson(result);\n        } catch (error) {\n          throw rpcErrors.internal(\n            `Received non-JSON-serializable value: ${error.message.replace(\n              /^Assertion failed: /u,\n              '',\n            )}`,\n          );\n        }\n      },\n      this.onTerminate.bind(this),\n    );\n  }\n\n  private errorHandler(error: unknown, data: Record<string, Json>) {\n    const serializedError = serializeError(error, {\n      fallbackError: unhandledError,\n      shouldIncludeStack: false,\n    });\n\n    const errorData = getErrorData(serializedError);\n\n    this.#notify({\n      method: 'UnhandledError',\n      params: {\n        error: {\n          ...serializedError,\n          data: {\n            ...errorData,\n            ...data,\n          },\n        },\n      },\n    }).catch((notifyError) => {\n      logError(notifyError);\n    });\n  }\n\n  private async onCommandRequest(message: JsonRpcRequest) {\n    if (!isJsonRpcRequest(message)) {\n      if (\n        hasProperty(message, 'id') &&\n        is((message as Pick<JsonRpcRequest, 'id'>).id, JsonRpcIdStruct)\n      ) {\n        // Instead of throwing, we directly respond with an error.\n        // We can only do this if the message ID is still valid.\n        await this.#write({\n          error: serializeError(\n            rpcErrors.internal(\n              'JSON-RPC requests must be JSON serializable objects.',\n            ),\n          ),\n          id: (message as Pick<JsonRpcRequest, 'id'>).id,\n          jsonrpc: '2.0',\n        });\n      } else {\n        logInfo(\n          'Command stream received a non-JSON-RPC request, and was unable to respond.',\n        );\n      }\n      return;\n    }\n\n    const { id, method, params } = message;\n\n    if (!hasProperty(EXECUTION_ENVIRONMENT_METHODS, method)) {\n      await this.#respond(id, {\n        error: rpcErrors\n          .methodNotFound({\n            data: {\n              method,\n            },\n          })\n          .serialize(),\n      });\n      return;\n    }\n\n    const methodObject = EXECUTION_ENVIRONMENT_METHODS[method as keyof Methods];\n\n    // support params by-name and by-position\n    const paramsAsArray = sortParamKeys(methodObject.params, params);\n\n    const [error] = validate<any, any>(paramsAsArray, methodObject.struct);\n    if (error) {\n      await this.#respond(id, {\n        error: rpcErrors\n          .invalidParams({\n            message: `Invalid parameters for method \"${method}\": ${error.message}.`,\n            data: {\n              method,\n              params: paramsAsArray,\n            },\n          })\n          .serialize(),\n      });\n      return;\n    }\n\n    try {\n      const result = await (this.methods as any)[method](...paramsAsArray);\n      await this.#respond(id, { result });\n    } catch (rpcError) {\n      await this.#respond(id, {\n        error: serializeError(rpcError, {\n          fallbackError,\n        }),\n      });\n    }\n  }\n\n  // Awaitable function that writes back to the command stream\n  // To prevent snap execution from blocking writing we wrap in a promise\n  // and await it before continuing execution\n  async #write(chunk: Json) {\n    return new Promise<void>((resolve, reject) => {\n      this.commandStream.write(chunk, (error) => {\n        if (error) {\n          reject(error);\n          return;\n        }\n        resolve();\n      });\n    });\n  }\n\n  async #notify(requestObject: Omit<JsonRpcNotification, 'jsonrpc'>) {\n    if (!isValidJson(requestObject) || !isObject(requestObject)) {\n      throw rpcErrors.internal(\n        'JSON-RPC notifications must be JSON serializable objects',\n      );\n    }\n\n    await this.#write({\n      ...requestObject,\n      jsonrpc: '2.0',\n    });\n  }\n\n  async #respond(id: JsonRpcId, requestObject: Record<string, unknown>) {\n    if (!isValidJson(requestObject) || !isObject(requestObject)) {\n      // Instead of throwing, we directly respond with an error.\n      // This prevents an issue where we wouldn't respond when errors were non-serializable\n      await this.#write({\n        error: serializeError(\n          rpcErrors.internal(\n            'JSON-RPC responses must be JSON serializable objects.',\n          ),\n        ),\n        id,\n        jsonrpc: '2.0',\n      });\n      return;\n    }\n\n    await this.#write({\n      ...requestObject,\n      id,\n      jsonrpc: '2.0',\n    });\n  }\n\n  /**\n   * Attempts to evaluate a snap in SES. Generates APIs for the snap. May throw\n   * on errors.\n   *\n   * @param snapId - The id of the snap.\n   * @param sourceCode - The source code of the snap, in IIFE format.\n   * @param _endowments - An array of the names of the endowments.\n   */\n  protected async startSnap(\n    snapId: string,\n    sourceCode: string,\n    _endowments: string[],\n  ): Promise<void> {\n    log(`Starting snap '${snapId}' in worker.`);\n    if (this.snapPromiseErrorHandler) {\n      removeEventListener('unhandledrejection', this.snapPromiseErrorHandler);\n    }\n\n    if (this.snapErrorHandler) {\n      removeEventListener('error', this.snapErrorHandler);\n    }\n\n    this.snapErrorHandler = (error: ErrorEvent) => {\n      this.errorHandler(error.error, { snapId });\n    };\n\n    this.snapPromiseErrorHandler = (error: PromiseRejectionEvent) => {\n      this.errorHandler(error instanceof Error ? error : error.reason, {\n        snapId,\n      });\n    };\n\n    const provider = new StreamProvider(this.rpcStream, {\n      jsonRpcStreamName: 'metamask-provider',\n      rpcMiddleware: [createIdRemapMiddleware()],\n    });\n\n    await provider.initialize();\n\n    const snap = this.createSnapGlobal(provider);\n    const ethereum = this.createEIP1193Provider(provider);\n    // We specifically use any type because the Snap can modify the object any way they want\n    const snapModule: any = { exports: {} };\n\n    try {\n      const { endowments, teardown: endowmentTeardown } = createEndowments({\n        snap,\n        ethereum,\n        snapId,\n        endowments: _endowments,\n        notify: this.#notify.bind(this),\n      });\n\n      // !!! Ensure that this is the only place the data is being set.\n      // Other methods access the object value and mutate its properties.\n      this.snapData.set(snapId, {\n        idleTeardown: endowmentTeardown,\n        runningEvaluations: new Set(),\n        exports: {},\n      });\n\n      addEventListener('unhandledRejection', this.snapPromiseErrorHandler);\n      addEventListener('error', this.snapErrorHandler);\n\n      const compartment = new Compartment({\n        ...endowments,\n        module: snapModule,\n        exports: snapModule.exports,\n      });\n\n      // All of those are JavaScript runtime specific and self referential,\n      // but we add them for compatibility sake with external libraries.\n      //\n      // We can't do that in the injected globals object above\n      // because SES creates its own globalThis\n      compartment.globalThis.self = compartment.globalThis;\n      compartment.globalThis.global = compartment.globalThis;\n      compartment.globalThis.window = compartment.globalThis;\n\n      await this.executeInSnapContext(snapId, () => {\n        compartment.evaluate(sourceCode);\n        this.registerSnapExports(snapId, snapModule);\n      });\n    } catch (error) {\n      this.removeSnap(snapId);\n\n      const [cause] = unwrapError(error);\n      throw rpcErrors.internal({\n        message: `Error while running snap '${snapId}': ${cause.message}`,\n        data: {\n          cause: cause.serialize(),\n        },\n      });\n    }\n  }\n\n  /**\n   * Cancels all running evaluations of all snaps and clears all snap data.\n   * NOTE:** Should only be called in response to the `terminate` RPC command.\n   */\n  protected onTerminate() {\n    // `stop()` tears down snap endowments.\n    // Teardown will also be run for each snap as soon as there are\n    // no more running evaluations for that snap.\n    this.snapData.forEach((data) =>\n      data.runningEvaluations.forEach((evaluation) => evaluation.stop()),\n    );\n    this.snapData.clear();\n  }\n\n  private registerSnapExports(snapId: string, snapModule: any) {\n    const data = this.snapData.get(snapId);\n    // Somebody deleted the snap before we could register.\n    if (!data) {\n      return;\n    }\n\n    data.exports = SNAP_EXPORT_NAMES.reduce((acc, exportName) => {\n      const snapExport = snapModule.exports[exportName];\n      const { validator } = SNAP_EXPORTS[exportName];\n      if (validator(snapExport)) {\n        return { ...acc, [exportName]: snapExport };\n      }\n      return acc;\n    }, {});\n  }\n\n  /**\n   * Instantiates a snap API object (i.e. `globalThis.snap`).\n   *\n   * @param provider - A StreamProvider connected to MetaMask.\n   * @returns The snap provider object.\n   */\n  private createSnapGlobal(provider: StreamProvider): SnapsProvider {\n    const originalRequest = provider.request.bind(provider);\n\n    const request = async (args: RequestArguments) => {\n      const sanitizedArgs = sanitizeRequestArguments(args);\n      assertSnapOutboundRequest(sanitizedArgs);\n      return await withTeardown(\n        (async () => {\n          await this.#notify({\n            method: 'OutboundRequest',\n            params: { source: 'snap.request' },\n          });\n          try {\n            return await originalRequest(sanitizedArgs);\n          } finally {\n            await this.#notify({\n              method: 'OutboundResponse',\n              params: { source: 'snap.request' },\n            });\n          }\n        })(),\n        this as any,\n      );\n    };\n\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 snapGlobalProxy = new Proxy(\n      {},\n      {\n        has(_target: object, prop: string | symbol) {\n          return typeof prop === 'string' && ['request'].includes(prop);\n        },\n        get(_target, prop: keyof StreamProvider) {\n          if (prop === 'request') {\n            return request;\n          }\n\n          return undefined;\n        },\n      },\n    ) as SnapsProvider;\n\n    return harden(snapGlobalProxy);\n  }\n\n  /**\n   * Instantiates an EIP-1193 Ethereum provider object (i.e. `globalThis.ethereum`).\n   *\n   * @param provider - A StreamProvider connected to MetaMask.\n   * @returns The EIP-1193 Ethereum provider object.\n   */\n  private createEIP1193Provider(provider: StreamProvider): StreamProvider {\n    const originalRequest = provider.request.bind(provider);\n\n    const request = async (args: RequestArguments) => {\n      const sanitizedArgs = sanitizeRequestArguments(args);\n      assertEthereumOutboundRequest(sanitizedArgs);\n      return await withTeardown(\n        (async () => {\n          await this.#notify({\n            method: 'OutboundRequest',\n            params: { source: 'ethereum.request' },\n          });\n          try {\n            return await originalRequest(sanitizedArgs);\n          } finally {\n            await this.#notify({\n              method: 'OutboundResponse',\n              params: { source: 'ethereum.request' },\n            });\n          }\n        })(),\n        this as any,\n      );\n    };\n\n    const streamProviderProxy = proxyStreamProvider(provider, request);\n\n    return harden(streamProviderProxy);\n  }\n\n  /**\n   * Removes the snap with the given name.\n   *\n   * @param snapId - The id of the snap to remove.\n   */\n  private removeSnap(snapId: string): void {\n    this.snapData.delete(snapId);\n  }\n\n  /**\n   * Calls the specified executor function in the context of the specified snap.\n   * Essentially, this means that the operation performed by the executor is\n   * counted as an evaluation of the specified snap. When the count of running\n   * evaluations of a snap reaches zero, its endowments are torn down.\n   *\n   * @param snapId - The id of the snap whose context to execute in.\n   * @param executor - The function that will be executed in the snap's context.\n   * @returns The executor's return value.\n   * @template Result - The return value of the executor.\n   */\n  private async executeInSnapContext<Result>(\n    snapId: string,\n    executor: () => Promise<Result> | Result,\n  ): Promise<Result> {\n    const data = this.snapData.get(snapId);\n    if (data === undefined) {\n      throw rpcErrors.internal(\n        `Tried to execute in context of unknown snap: \"${snapId}\".`,\n      );\n    }\n\n    let stop: () => void;\n    const stopPromise = new Promise<never>(\n      (_, reject) =>\n        (stop = () =>\n          reject(\n            // TODO(rekmarks): Specify / standardize error code for this case.\n            rpcErrors.internal(\n              `The snap \"${snapId}\" has been terminated during execution.`,\n            ),\n          )),\n    );\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const evaluationData = { stop: stop! };\n\n    try {\n      data.runningEvaluations.add(evaluationData);\n      // Notice that we have to await this executor.\n      // If we didn't, we would decrease the amount of running evaluations\n      // before the promise actually resolves\n      return await Promise.race([executor(), stopPromise]);\n    } catch (error) {\n      throw new WrappedSnapError(error);\n    } finally {\n      data.runningEvaluations.delete(evaluationData);\n\n      if (data.runningEvaluations.size === 0) {\n        this.lastTeardown += 1;\n        await data.idleTeardown();\n      }\n    }\n  }\n}\n"],"names":["createIdRemapMiddleware","StreamProvider","errorCodes","rpcErrors","serializeError","getErrorData","SNAP_EXPORT_NAMES","logError","SNAP_EXPORTS","WrappedSnapError","unwrapError","logInfo","isObject","isValidJson","assert","isJsonRpcRequest","hasProperty","getSafeJson","JsonRpcIdStruct","validate","is","log","getCommandMethodImplementations","createEndowments","addEventListener","removeEventListener","sortParamKeys","assertEthereumOutboundRequest","assertSnapOutboundRequest","sanitizeRequestArguments","proxyStreamProvider","withTeardown","ExecuteSnapRequestArgumentsStruct","PingRequestArgumentsStruct","SnapRpcRequestArgumentsStruct","TerminateRequestArgumentsStruct","fallbackError","code","rpc","internal","message","unhandledError","serialize","EXECUTION_ENVIRONMENT_METHODS","ping","struct","params","executeSnap","terminate","snapRpc","BaseSnapExecutor","errorHandler","error","data","serializedError","shouldIncludeStack","errorData","notify","method","catch","notifyError","onCommandRequest","id","write","jsonrpc","respond","methodNotFound","methodObject","paramsAsArray","invalidParams","result","methods","rpcError","startSnap","snapId","sourceCode","_endowments","snapPromiseErrorHandler","snapErrorHandler","Error","reason","provider","rpcStream","jsonRpcStreamName","rpcMiddleware","initialize","snap","createSnapGlobal","ethereum","createEIP1193Provider","snapModule","exports","endowments","teardown","endowmentTeardown","bind","snapData","set","idleTeardown","runningEvaluations","Set","compartment","Compartment","module","globalThis","self","global","window","executeInSnapContext","evaluate","registerSnapExports","removeSnap","cause","onTerminate","forEach","evaluation","stop","clear","get","reduce","acc","exportName","snapExport","validator","originalRequest","request","args","sanitizedArgs","source","snapGlobalProxy","Proxy","has","_target","prop","includes","undefined","harden","streamProviderProxy","delete","executor","stopPromise","Promise","_","reject","evaluationData","add","race","size","lastTeardown","commandStream","Map","on","target","handlerType","handler","required","methodNotSupported","replace","chunk","resolve","requestObject"],"mappings":"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"}

package/dist/esm/common/commands.js

@@ -1,101 +0,0 @@
-import { HandlerType } from '@metamask/snaps-utils';
-import { assertExhaustive } from '@metamask/utils';
-import { assertIsOnTransactionRequestArguments, assertIsOnSignatureRequestArguments, assertIsOnNameLookupRequestArguments, assertIsOnUserInputRequestArguments } from './validation';
-/**
- * Formats the arguments for the given handler.
- *
- * @param origin - The origin of the request.
- * @param handler - The handler to pass the request to.
- * @param request - The request object.
- * @returns The formatted arguments.
- */ export function getHandlerArguments(origin, handler, request) {
-    // `request` is already validated by the time this function is called.
-    switch(handler){
-        case HandlerType.OnTransaction:
-            {
-                assertIsOnTransactionRequestArguments(request.params);
-                const { transaction, chainId, transactionOrigin } = request.params;
-                return {
-                    transaction,
-                    chainId,
-                    transactionOrigin
-                };
-            }
-        case HandlerType.OnSignature:
-            {
-                assertIsOnSignatureRequestArguments(request.params);
-                const { signature, signatureOrigin } = request.params;
-                return {
-                    signature,
-                    signatureOrigin
-                };
-            }
-        case HandlerType.OnNameLookup:
-            {
-                assertIsOnNameLookupRequestArguments(request.params);
-                // TS complains that domain/address are not part of the type
-                // casting here as we've already validated the request args in the above step.
-                const { chainId, domain, address } = request.params;
-                return domain ? {
-                    chainId,
-                    domain
-                } : {
-                    chainId,
-                    address
-                };
-            }
-        case HandlerType.OnRpcRequest:
-        case HandlerType.OnKeyringRequest:
-            return {
-                origin,
-                request
-            };
-        case HandlerType.OnCronjob:
-        case HandlerType.OnInstall:
-        case HandlerType.OnUpdate:
-            return {
-                request
-            };
-        case HandlerType.OnHomePage:
-            return {};
-        case HandlerType.OnUserInput:
-            {
-                assertIsOnUserInputRequestArguments(request.params);
-                const { id, event } = request.params;
-                return {
-                    id,
-                    event
-                };
-            }
-        default:
-            return assertExhaustive(handler);
-    }
-}
-/**
- * Gets an object mapping internal, "command" JSON-RPC method names to their
- * implementations.
- *
- * @param startSnap - A function that starts a snap.
- * @param invokeSnap - A function that invokes the RPC method handler of a
- * snap.
- * @param onTerminate - A function that will be called when this executor is
- * terminated in order to handle cleanup tasks.
- * @returns An object containing the "command" method implementations.
- */ export function getCommandMethodImplementations(startSnap, invokeSnap, onTerminate) {
-    return {
-        ping: async ()=>Promise.resolve('OK'),
-        terminate: async ()=>{
-            onTerminate();
-            return Promise.resolve('OK');
-        },
-        executeSnap: async (snapId, sourceCode, endowments)=>{
-            await startSnap(snapId, sourceCode, endowments);
-            return 'OK';
-        },
-        snapRpc: async (target, handler, origin, request)=>{
-            return await invokeSnap(target, handler, getHandlerArguments(origin, handler, request)) ?? null;
-        }
-    };
-}
-
-//# sourceMappingURL=commands.js.map