@metamask/snaps-controllers 5.0.1 → 6.0.0

package/dist/chunk-35RVMQQU.mjs

@@ -0,0 +1,283 @@
+import {
+  getRunnableSnaps
+} from "./chunk-5JX3PHKY.mjs";
+import {
+  Timer
+} from "./chunk-5526GKFY.mjs";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-YRZVIDCF.mjs";
+
+// src/cronjob/CronjobController.ts
+import { BaseController } from "@metamask/base-controller";
+import {
+  getCronjobCaveatJobs,
+  SnapEndowments
+} from "@metamask/snaps-rpc-methods";
+import {
+  HandlerType,
+  parseCronExpression,
+  logError
+} from "@metamask/snaps-utils";
+import { Duration, inMilliseconds } from "@metamask/utils";
+var DAILY_TIMEOUT = inMilliseconds(24, Duration.Hour);
+var controllerName = "CronjobController";
+var _messenger, _dailyTimer, _timers, _snapIds;
+var CronjobController = class extends BaseController {
+  constructor({ messenger, state }) {
+    super({
+      messenger,
+      metadata: {
+        jobs: { persist: true, anonymous: false }
+      },
+      name: controllerName,
+      state: {
+        jobs: {},
+        ...state
+      }
+    });
+    __privateAdd(this, _messenger, void 0);
+    __privateAdd(this, _dailyTimer, void 0);
+    __privateAdd(this, _timers, void 0);
+    // Mapping from jobId to snapId
+    __privateAdd(this, _snapIds, void 0);
+    __privateSet(this, _timers, /* @__PURE__ */ new Map());
+    __privateSet(this, _snapIds, /* @__PURE__ */ new Map());
+    __privateSet(this, _messenger, messenger);
+    this._handleSnapRegisterEvent = this._handleSnapRegisterEvent.bind(this);
+    this._handleSnapUnregisterEvent = this._handleSnapUnregisterEvent.bind(this);
+    this._handleEventSnapUpdated = this._handleEventSnapUpdated.bind(this);
+    this.messagingSystem.subscribe(
+      "SnapController:snapInstalled",
+      this._handleSnapRegisterEvent
+    );
+    this.messagingSystem.subscribe(
+      "SnapController:snapUninstalled",
+      this._handleSnapUnregisterEvent
+    );
+    this.messagingSystem.subscribe(
+      "SnapController:snapEnabled",
+      this._handleSnapRegisterEvent
+    );
+    this.messagingSystem.subscribe(
+      "SnapController:snapDisabled",
+      this._handleSnapUnregisterEvent
+    );
+    this.messagingSystem.subscribe(
+      "SnapController:snapUpdated",
+      this._handleEventSnapUpdated
+    );
+    this.dailyCheckIn().catch((error) => {
+      logError(error);
+    });
+  }
+  /**
+   * Retrieve all cronjob specifications for all runnable snaps.
+   *
+   * @returns Array of Cronjob specifications.
+   */
+  getAllJobs() {
+    const snaps = this.messagingSystem.call("SnapController:getAll");
+    const filteredSnaps = getRunnableSnaps(snaps);
+    const jobs = filteredSnaps.map((snap) => this.getSnapJobs(snap.id));
+    return jobs.flat().filter((job) => job !== void 0);
+  }
+  /**
+   * Retrieve all Cronjob specifications for a Snap.
+   *
+   * @param snapId - ID of a Snap.
+   * @returns Array of Cronjob specifications.
+   */
+  getSnapJobs(snapId) {
+    const permissions = __privateGet(this, _messenger).call(
+      "PermissionController:getPermissions",
+      snapId
+    );
+    const permission = permissions?.[SnapEndowments.Cronjob];
+    const definitions = getCronjobCaveatJobs(permission);
+    return definitions?.map((definition, idx) => {
+      return { ...definition, id: `${snapId}-${idx}`, snapId };
+    });
+  }
+  /**
+   * Register cron jobs for a given snap by getting specification from a permission caveats.
+   * Once registered, each job will be scheduled.
+   *
+   * @param snapId - ID of a snap.
+   */
+  register(snapId) {
+    const jobs = this.getSnapJobs(snapId);
+    jobs?.forEach((job) => this.schedule(job));
+  }
+  /**
+   * Schedule a new job.
+   * This will interpret the cron expression and tell the timer to execute the job
+   * at the next suitable point in time.
+   * Job last run state will be initialized afterwards.
+   *
+   * Note: Schedule will be skipped if the job's execution time is too far in the future and
+   * will be revisited on a daily check.
+   *
+   * @param job - Cronjob specification.
+   */
+  schedule(job) {
+    if (__privateGet(this, _timers).has(job.id)) {
+      return;
+    }
+    const parsed = parseCronExpression(job.expression);
+    const next = parsed.next();
+    const now = /* @__PURE__ */ new Date();
+    const ms = next.getTime() - now.getTime();
+    if (ms > DAILY_TIMEOUT) {
+      return;
+    }
+    const timer = new Timer(ms);
+    timer.start(() => {
+      this.executeCronjob(job).catch((error) => {
+        logError(error);
+      });
+      __privateGet(this, _timers).delete(job.id);
+      this.schedule(job);
+    });
+    if (!this.state.jobs[job.id]?.lastRun) {
+      this.updateJobLastRunState(job.id, 0);
+    }
+    __privateGet(this, _timers).set(job.id, timer);
+    __privateGet(this, _snapIds).set(job.id, job.snapId);
+  }
+  /**
+   * Execute job.
+   *
+   * @param job - Cronjob specification.
+   */
+  async executeCronjob(job) {
+    this.updateJobLastRunState(job.id, Date.now());
+    await __privateGet(this, _messenger).call("SnapController:handleRequest", {
+      snapId: job.snapId,
+      origin: "",
+      handler: HandlerType.OnCronjob,
+      request: job.request
+    });
+  }
+  /**
+   * Unregister all jobs related to the given snapId.
+   *
+   * @param snapId - ID of a snap.
+   */
+  unregister(snapId) {
+    const jobs = [...__privateGet(this, _snapIds).entries()].filter(
+      ([_, jobSnapId]) => jobSnapId === snapId
+    );
+    if (jobs.length) {
+      jobs.forEach(([id]) => {
+        const timer = __privateGet(this, _timers).get(id);
+        if (timer) {
+          timer.cancel();
+          __privateGet(this, _timers).delete(id);
+          __privateGet(this, _snapIds).delete(id);
+        }
+      });
+    }
+  }
+  /**
+   * Update time of a last run for the Cronjob specified by ID.
+   *
+   * @param jobId - ID of a cron job.
+   * @param lastRun - Unix timestamp when the job was last ran.
+   */
+  updateJobLastRunState(jobId, lastRun) {
+    this.update((state) => {
+      state.jobs[jobId] = {
+        lastRun
+      };
+    });
+  }
+  /**
+   * Runs every 24 hours to check if new jobs need to be scheduled.
+   *
+   * This is necessary for longer running jobs that execute with more than 24 hours between them.
+   */
+  async dailyCheckIn() {
+    const jobs = this.getAllJobs();
+    for (const job of jobs) {
+      const parsed = parseCronExpression(job.expression);
+      const lastRun = this.state.jobs[job.id]?.lastRun;
+      if (lastRun !== void 0 && parsed.hasPrev() && parsed.prev().getTime() > lastRun) {
+        await this.executeCronjob(job);
+      }
+      this.schedule(job);
+    }
+    __privateSet(this, _dailyTimer, new Timer(DAILY_TIMEOUT));
+    __privateGet(this, _dailyTimer).start(() => {
+      this.dailyCheckIn().catch((error) => {
+        logError(error);
+      });
+    });
+  }
+  /**
+   * Run controller teardown process and unsubscribe from Snap events.
+   */
+  destroy() {
+    super.destroy();
+    this.messagingSystem.unsubscribe(
+      "SnapController:snapInstalled",
+      this._handleSnapRegisterEvent
+    );
+    this.messagingSystem.unsubscribe(
+      "SnapController:snapUninstalled",
+      this._handleSnapUnregisterEvent
+    );
+    this.messagingSystem.unsubscribe(
+      "SnapController:snapEnabled",
+      this._handleSnapRegisterEvent
+    );
+    this.messagingSystem.unsubscribe(
+      "SnapController:snapDisabled",
+      this._handleSnapUnregisterEvent
+    );
+    this.messagingSystem.unsubscribe(
+      "SnapController:snapUpdated",
+      this._handleEventSnapUpdated
+    );
+    __privateGet(this, _snapIds).forEach((snapId) => {
+      this.unregister(snapId);
+    });
+  }
+  /**
+   * Handle events that should cause cronjobs to be registered.
+   *
+   * @param snap - Basic Snap information.
+   */
+  _handleSnapRegisterEvent(snap) {
+    this.register(snap.id);
+  }
+  /**
+   * Handle events that should cause cronjobs to be unregistered.
+   *
+   * @param snap - Basic Snap information.
+   */
+  _handleSnapUnregisterEvent(snap) {
+    this.unregister(snap.id);
+  }
+  /**
+   * Handle cron jobs on 'snapUpdated' event.
+   *
+   * @param snap - Basic Snap information.
+   */
+  _handleEventSnapUpdated(snap) {
+    this.unregister(snap.id);
+    this.register(snap.id);
+  }
+};
+_messenger = new WeakMap();
+_dailyTimer = new WeakMap();
+_timers = new WeakMap();
+_snapIds = new WeakMap();
+
+export {
+  DAILY_TIMEOUT,
+  CronjobController
+};
+//# sourceMappingURL=chunk-35RVMQQU.mjs.map

package/dist/chunk-35RVMQQU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cronjob/CronjobController.ts"],"sourcesContent":["import type { RestrictedControllerMessenger } from '@metamask/base-controller';\nimport { BaseController } from '@metamask/base-controller';\nimport type { GetPermissions } from '@metamask/permission-controller';\nimport {\n  getCronjobCaveatJobs,\n  SnapEndowments,\n} from '@metamask/snaps-rpc-methods';\nimport type { SnapId } from '@metamask/snaps-sdk';\nimport type {\n  TruncatedSnap,\n  CronjobSpecification,\n} from '@metamask/snaps-utils';\nimport {\n  HandlerType,\n  parseCronExpression,\n  logError,\n} from '@metamask/snaps-utils';\nimport { Duration, inMilliseconds } from '@metamask/utils';\n\nimport type {\n  GetAllSnaps,\n  HandleSnapRequest,\n  SnapDisabled,\n  SnapEnabled,\n  SnapInstalled,\n  SnapUninstalled,\n  SnapUpdated,\n} from '..';\nimport { getRunnableSnaps } from '..';\nimport { Timer } from '../snaps/Timer';\n\nexport type CronjobControllerActions =\n  | GetAllSnaps\n  | HandleSnapRequest\n  | GetPermissions;\n\nexport type CronjobControllerEvents =\n  | SnapInstalled\n  | SnapUninstalled\n  | SnapUpdated\n  | SnapEnabled\n  | SnapDisabled;\n\nexport type CronjobControllerMessenger = RestrictedControllerMessenger<\n  'CronjobController',\n  CronjobControllerActions,\n  CronjobControllerEvents,\n  CronjobControllerActions['type'],\n  CronjobControllerEvents['type']\n>;\n\nexport const DAILY_TIMEOUT = inMilliseconds(24, Duration.Hour);\n\nexport type CronjobControllerArgs = {\n  messenger: CronjobControllerMessenger;\n  /**\n   * Persisted state that will be used for rehydration.\n   */\n  state?: CronjobControllerState;\n};\n\nexport type Cronjob = {\n  timer?: Timer;\n  id: string;\n  snapId: SnapId;\n} & CronjobSpecification;\n\nexport type StoredJobInformation = {\n  lastRun: number;\n};\n\nexport type CronjobControllerState = {\n  jobs: Record<string, StoredJobInformation>;\n};\n\nconst controllerName = 'CronjobController';\n\n/**\n * Use this controller to register and schedule periodically executed jobs\n * using RPC method hooks.\n */\nexport class CronjobController extends BaseController<\n  typeof controllerName,\n  CronjobControllerState,\n  CronjobControllerMessenger\n> {\n  #messenger: CronjobControllerMessenger;\n\n  #dailyTimer!: Timer;\n\n  #timers: Map<string, Timer>;\n\n  // Mapping from jobId to snapId\n  #snapIds: Map<string, string>;\n\n  constructor({ messenger, state }: CronjobControllerArgs) {\n    super({\n      messenger,\n      metadata: {\n        jobs: { persist: true, anonymous: false },\n      },\n      name: controllerName,\n      state: {\n        jobs: {},\n        ...state,\n      },\n    });\n    this.#timers = new Map();\n    this.#snapIds = new Map();\n    this.#messenger = messenger;\n\n    this._handleSnapRegisterEvent = this._handleSnapRegisterEvent.bind(this);\n    this._handleSnapUnregisterEvent =\n      this._handleSnapUnregisterEvent.bind(this);\n    this._handleEventSnapUpdated = this._handleEventSnapUpdated.bind(this);\n\n    // Subscribe to Snap events\n    /* eslint-disable @typescript-eslint/unbound-method */\n    this.messagingSystem.subscribe(\n      'SnapController:snapInstalled',\n      this._handleSnapRegisterEvent,\n    );\n\n    this.messagingSystem.subscribe(\n      'SnapController:snapUninstalled',\n      this._handleSnapUnregisterEvent,\n    );\n\n    this.messagingSystem.subscribe(\n      'SnapController:snapEnabled',\n      this._handleSnapRegisterEvent,\n    );\n\n    this.messagingSystem.subscribe(\n      'SnapController:snapDisabled',\n      this._handleSnapUnregisterEvent,\n    );\n\n    this.messagingSystem.subscribe(\n      'SnapController:snapUpdated',\n      this._handleEventSnapUpdated,\n    );\n    /* eslint-enable @typescript-eslint/unbound-method */\n\n    this.dailyCheckIn().catch((error) => {\n      logError(error);\n    });\n  }\n\n  /**\n   * Retrieve all cronjob specifications for all runnable snaps.\n   *\n   * @returns Array of Cronjob specifications.\n   */\n  private getAllJobs(): Cronjob[] {\n    const snaps = this.messagingSystem.call('SnapController:getAll');\n    const filteredSnaps = getRunnableSnaps(snaps);\n\n    const jobs = filteredSnaps.map((snap) => this.getSnapJobs(snap.id));\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n    return jobs.flat().filter((job) => job !== undefined) as Cronjob[];\n  }\n\n  /**\n   * Retrieve all Cronjob specifications for a Snap.\n   *\n   * @param snapId - ID of a Snap.\n   * @returns Array of Cronjob specifications.\n   */\n  private getSnapJobs(snapId: SnapId): Cronjob[] | undefined {\n    const permissions = this.#messenger.call(\n      'PermissionController:getPermissions',\n      snapId,\n    );\n\n    const permission = permissions?.[SnapEndowments.Cronjob];\n    const definitions = getCronjobCaveatJobs(permission);\n\n    return definitions?.map((definition, idx) => {\n      return { ...definition, id: `${snapId}-${idx}`, snapId };\n    });\n  }\n\n  /**\n   * Register cron jobs for a given snap by getting specification from a permission caveats.\n   * Once registered, each job will be scheduled.\n   *\n   * @param snapId - ID of a snap.\n   */\n  register(snapId: SnapId) {\n    const jobs = this.getSnapJobs(snapId);\n    jobs?.forEach((job) => this.schedule(job));\n  }\n\n  /**\n   * Schedule a new job.\n   * This will interpret the cron expression and tell the timer to execute the job\n   * at the next suitable point in time.\n   * Job last run state will be initialized afterwards.\n   *\n   * Note: Schedule will be skipped if the job's execution time is too far in the future and\n   * will be revisited on a daily check.\n   *\n   * @param job - Cronjob specification.\n   */\n  private schedule(job: Cronjob) {\n    if (this.#timers.has(job.id)) {\n      return;\n    }\n\n    const parsed = parseCronExpression(job.expression);\n    const next = parsed.next();\n    const now = new Date();\n    const ms = next.getTime() - now.getTime();\n\n    // Don't schedule this job yet as it is too far in the future\n    if (ms > DAILY_TIMEOUT) {\n      return;\n    }\n\n    const timer = new Timer(ms);\n    timer.start(() => {\n      this.executeCronjob(job).catch((error) => {\n        // TODO: Decide how to handle errors.\n        logError(error);\n      });\n\n      this.#timers.delete(job.id);\n      this.schedule(job);\n    });\n\n    if (!this.state.jobs[job.id]?.lastRun) {\n      this.updateJobLastRunState(job.id, 0); // 0 for init, never ran actually\n    }\n\n    this.#timers.set(job.id, timer);\n    this.#snapIds.set(job.id, job.snapId);\n  }\n\n  /**\n   * Execute job.\n   *\n   * @param job - Cronjob specification.\n   */\n  private async executeCronjob(job: Cronjob) {\n    this.updateJobLastRunState(job.id, Date.now());\n    await this.#messenger.call('SnapController:handleRequest', {\n      snapId: job.snapId,\n      origin: '',\n      handler: HandlerType.OnCronjob,\n      request: job.request,\n    });\n  }\n\n  /**\n   * Unregister all jobs related to the given snapId.\n   *\n   * @param snapId - ID of a snap.\n   */\n  unregister(snapId: string) {\n    const jobs = [...this.#snapIds.entries()].filter(\n      ([_, jobSnapId]) => jobSnapId === snapId,\n    );\n\n    if (jobs.length) {\n      jobs.forEach(([id]) => {\n        const timer = this.#timers.get(id);\n        if (timer) {\n          timer.cancel();\n          this.#timers.delete(id);\n          this.#snapIds.delete(id);\n        }\n      });\n    }\n  }\n\n  /**\n   * Update time of a last run for the Cronjob specified by ID.\n   *\n   * @param jobId - ID of a cron job.\n   * @param lastRun - Unix timestamp when the job was last ran.\n   */\n  private updateJobLastRunState(jobId: string, lastRun: number) {\n    this.update((state) => {\n      state.jobs[jobId] = {\n        lastRun,\n      };\n    });\n  }\n\n  /**\n   * Runs every 24 hours to check if new jobs need to be scheduled.\n   *\n   * This is necessary for longer running jobs that execute with more than 24 hours between them.\n   */\n  async dailyCheckIn() {\n    const jobs = this.getAllJobs();\n\n    for (const job of jobs) {\n      const parsed = parseCronExpression(job.expression);\n      const lastRun = this.state.jobs[job.id]?.lastRun;\n      // If a job was supposed to run while we were shut down but wasn't we run it now\n      if (\n        lastRun !== undefined &&\n        parsed.hasPrev() &&\n        parsed.prev().getTime() > lastRun\n      ) {\n        await this.executeCronjob(job);\n      }\n\n      // Try scheduling, will fail if an existing scheduled job is found\n      this.schedule(job);\n    }\n\n    this.#dailyTimer = new Timer(DAILY_TIMEOUT);\n    this.#dailyTimer.start(() => {\n      this.dailyCheckIn().catch((error) => {\n        // TODO: Decide how to handle errors.\n        logError(error);\n      });\n    });\n  }\n\n  /**\n   * Run controller teardown process and unsubscribe from Snap events.\n   */\n  destroy() {\n    super.destroy();\n\n    /* eslint-disable @typescript-eslint/unbound-method */\n    this.messagingSystem.unsubscribe(\n      'SnapController:snapInstalled',\n      this._handleSnapRegisterEvent,\n    );\n\n    this.messagingSystem.unsubscribe(\n      'SnapController:snapUninstalled',\n      this._handleSnapUnregisterEvent,\n    );\n\n    this.messagingSystem.unsubscribe(\n      'SnapController:snapEnabled',\n      this._handleSnapRegisterEvent,\n    );\n\n    this.messagingSystem.unsubscribe(\n      'SnapController:snapDisabled',\n      this._handleSnapUnregisterEvent,\n    );\n\n    this.messagingSystem.unsubscribe(\n      'SnapController:snapUpdated',\n      this._handleEventSnapUpdated,\n    );\n    /* eslint-enable @typescript-eslint/unbound-method */\n\n    this.#snapIds.forEach((snapId) => {\n      this.unregister(snapId);\n    });\n  }\n\n  /**\n   * Handle events that should cause cronjobs to be registered.\n   *\n   * @param snap - Basic Snap information.\n   */\n  private _handleSnapRegisterEvent(snap: TruncatedSnap) {\n    this.register(snap.id);\n  }\n\n  /**\n   * Handle events that should cause cronjobs to be unregistered.\n   *\n   * @param snap - Basic Snap information.\n   */\n  private _handleSnapUnregisterEvent(snap: TruncatedSnap) {\n    this.unregister(snap.id);\n  }\n\n  /**\n   * Handle cron jobs on 'snapUpdated' event.\n   *\n   * @param snap - Basic Snap information.\n   */\n  private _handleEventSnapUpdated(snap: TruncatedSnap) {\n    this.unregister(snap.id);\n    this.register(snap.id);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-3EJ6JINY.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-3EJ6JINY.mjs.map

package/dist/chunk-3EJ6JINY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-3RXU6FL7.js

@@ -0,0 +1,354 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunk66XO4TRYjs = require('./chunk-66XO4TRY.js');
+
+
+
+var _chunkBGJPFPCHjs = require('./chunk-BGJPFPCH.js');
+
+
+
+
+
+var _chunkEXN2TFDJjs = require('./chunk-EXN2TFDJ.js');
+
+// src/services/AbstractExecutionService.ts
+var _jsonrpcengine = require('@metamask/json-rpc-engine');
+var _objectmultiplex = require('@metamask/object-multiplex'); var _objectmultiplex2 = _interopRequireDefault(_objectmultiplex);
+var _rpcerrors = require('@metamask/rpc-errors');
+var _snapsutils = require('@metamask/snaps-utils');
+
+
+
+
+
+var _utils = require('@metamask/utils');
+var _jsonrpcmiddlewarestream = require('json-rpc-middleware-stream');
+var _nanoid = require('nanoid');
+var _readablestream = require('readable-stream');
+var controllerName = "ExecutionService";
+var _snapRpcHooks, _snapToJobMap, _jobToSnapMap, _messenger, _terminationTimeout, _removeSnapHooks, removeSnapHooks_fn, _createSnapHooks, createSnapHooks_fn, _mapSnapAndJob, mapSnapAndJob_fn, _removeSnapAndJobMapping, removeSnapAndJobMapping_fn;
+var AbstractExecutionService = class {
+  constructor({
+    setupSnapProvider,
+    messenger,
+    terminationTimeout = _utils.Duration.Second
+  }) {
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _removeSnapHooks);
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _createSnapHooks);
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _mapSnapAndJob);
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _removeSnapAndJobMapping);
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _snapRpcHooks, void 0);
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _snapToJobMap, void 0);
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _jobToSnapMap, void 0);
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _messenger, void 0);
+    _chunkEXN2TFDJjs.__privateAdd.call(void 0, this, _terminationTimeout, void 0);
+    _chunkEXN2TFDJjs.__privateSet.call(void 0, this, _snapRpcHooks, /* @__PURE__ */ new Map());
+    this.jobs = /* @__PURE__ */ new Map();
+    this.setupSnapProvider = setupSnapProvider;
+    _chunkEXN2TFDJjs.__privateSet.call(void 0, this, _snapToJobMap, /* @__PURE__ */ new Map());
+    _chunkEXN2TFDJjs.__privateSet.call(void 0, this, _jobToSnapMap, /* @__PURE__ */ new Map());
+    _chunkEXN2TFDJjs.__privateSet.call(void 0, this, _messenger, messenger);
+    _chunkEXN2TFDJjs.__privateSet.call(void 0, this, _terminationTimeout, terminationTimeout);
+    this.registerMessageHandlers();
+  }
+  /**
+   * Constructor helper for registering the controller's messaging system
+   * actions.
+   */
+  registerMessageHandlers() {
+    _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _messenger).registerActionHandler(
+      `${controllerName}:handleRpcRequest`,
+      async (snapId, options) => this.handleRpcRequest(snapId, options)
+    );
+    _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _messenger).registerActionHandler(
+      `${controllerName}:executeSnap`,
+      async (snapData) => this.executeSnap(snapData)
+    );
+    _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _messenger).registerActionHandler(
+      `${controllerName}:terminateSnap`,
+      async (snapId) => this.terminateSnap(snapId)
+    );
+    _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _messenger).registerActionHandler(
+      `${controllerName}:terminateAllSnaps`,
+      async () => this.terminateAllSnaps()
+    );
+  }
+  /**
+   * Terminates the job with the specified ID and deletes all its associated
+   * data. Any subsequent messages targeting the job will fail with an error.
+   * Throws an error if the specified job does not exist, or if termination
+   * fails unexpectedly.
+   *
+   * @param jobId - The id of the job to be terminated.
+   */
+  async terminate(jobId) {
+    const jobWrapper = this.jobs.get(jobId);
+    if (!jobWrapper) {
+      throw new Error(`Job with id "${jobId}" not found.`);
+    }
+    const result = await _chunkBGJPFPCHjs.withTimeout.call(void 0, 
+      this.command(jobId, {
+        jsonrpc: "2.0",
+        method: "terminate",
+        params: [],
+        id: _nanoid.nanoid.call(void 0, )
+      }),
+      _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _terminationTimeout)
+    );
+    if (result === _chunkBGJPFPCHjs.hasTimedOut || result !== "OK") {
+      _snapsutils.logError.call(void 0, `Job "${jobId}" failed to terminate gracefully.`, result);
+    }
+    Object.values(jobWrapper.streams).forEach((stream) => {
+      try {
+        !stream.destroyed && stream.destroy();
+        stream.removeAllListeners();
+      } catch (error) {
+        _snapsutils.logError.call(void 0, "Error while destroying stream", error);
+      }
+    });
+    this.terminateJob(jobWrapper);
+    _chunkEXN2TFDJjs.__privateMethod.call(void 0, this, _removeSnapAndJobMapping, removeSnapAndJobMapping_fn).call(this, jobId);
+    this.jobs.delete(jobId);
+    _chunk66XO4TRYjs.log.call(void 0, `Job "${jobId}" terminated.`);
+  }
+  /**
+   * Initiates a job for a snap.
+   *
+   * Depending on the execution environment, this may run forever if the Snap fails to start up properly, therefore any call to this function should be wrapped in a timeout.
+   *
+   * @returns Information regarding the created job.
+   */
+  async initJob() {
+    const jobId = _nanoid.nanoid.call(void 0, );
+    const { streams, worker } = await this.initStreams(jobId);
+    const rpcEngine = new (0, _jsonrpcengine.JsonRpcEngine)();
+    const jsonRpcConnection = _jsonrpcmiddlewarestream.createStreamMiddleware.call(void 0, );
+    _readablestream.pipeline.call(void 0, 
+      jsonRpcConnection.stream,
+      streams.command,
+      jsonRpcConnection.stream,
+      (error) => {
+        if (error) {
+          _snapsutils.logError.call(void 0, `Command stream failure.`, error);
+        }
+      }
+    );
+    rpcEngine.push(jsonRpcConnection.middleware);
+    const envMetadata = {
+      id: jobId,
+      streams,
+      rpcEngine,
+      worker
+    };
+    this.jobs.set(jobId, envMetadata);
+    return envMetadata;
+  }
+  /**
+   * Sets up the streams for an initiated job.
+   *
+   * Depending on the execution environment, this may run forever if the Snap fails to start up properly, therefore any call to this function should be wrapped in a timeout.
+   *
+   * @param jobId - The id of the job.
+   * @returns The streams to communicate with the worker and the worker itself.
+   */
+  async initStreams(jobId) {
+    const { worker, stream: envStream } = await this.initEnvStream(jobId);
+    const mux = setupMultiplex(envStream, `Job: "${jobId}"`);
+    const commandStream = mux.createStream(_snapsutils.SNAP_STREAM_NAMES.COMMAND);
+    const notificationHandler = (message) => {
+      if (!_utils.isJsonRpcNotification.call(void 0, message)) {
+        return;
+      }
+      const snapId = _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _jobToSnapMap).get(jobId);
+      if (message.method === "OutboundRequest") {
+        _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _messenger).publish("ExecutionService:outboundRequest", snapId);
+      } else if (message.method === "OutboundResponse") {
+        _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _messenger).publish("ExecutionService:outboundResponse", snapId);
+      } else if (message.method === "UnhandledError") {
+        if (_utils.isObject.call(void 0, message.params) && message.params.error) {
+          _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _messenger).publish(
+            "ExecutionService:unhandledError",
+            snapId,
+            message.params.error
+          );
+          commandStream.removeListener("data", notificationHandler);
+        } else {
+          _snapsutils.logError.call(void 0, 
+            new Error(
+              `Received malformed "${message.method}" command stream notification.`
+            )
+          );
+        }
+      } else {
+        _snapsutils.logError.call(void 0, 
+          new Error(
+            `Received unexpected command stream notification "${message.method}".`
+          )
+        );
+      }
+    };
+    commandStream.on("data", notificationHandler);
+    const rpcStream = mux.createStream(_snapsutils.SNAP_STREAM_NAMES.JSON_RPC);
+    return {
+      streams: {
+        command: commandStream,
+        rpc: rpcStream,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        _connection: envStream
+      },
+      worker
+    };
+  }
+  /**
+   * Terminates the Snap with the specified ID. May throw an error if
+   * termination unexpectedly fails, but will not fail if no job for the snap
+   * with the specified ID is found.
+   *
+   * @param snapId - The ID of the snap to terminate.
+   */
+  async terminateSnap(snapId) {
+    const jobId = _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _snapToJobMap).get(snapId);
+    if (jobId) {
+      await this.terminate(jobId);
+    }
+  }
+  async terminateAllSnaps() {
+    await Promise.all(
+      [...this.jobs.keys()].map(async (jobId) => this.terminate(jobId))
+    );
+    _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _snapRpcHooks).clear();
+  }
+  /**
+   * Gets the RPC request handler for the given snap.
+   *
+   * @param snapId - The id of the Snap whose message handler to get.
+   * @returns The RPC request handler for the snap.
+   */
+  getRpcRequestHandler(snapId) {
+    return _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _snapRpcHooks).get(snapId);
+  }
+  /**
+   * Initializes and executes a snap, setting up the communication channels to the snap etc.
+   *
+   * Depending on the execution environment, this may run forever if the Snap fails to start up properly, therefore any call to this function should be wrapped in a timeout.
+   *
+   * @param snapData - Data needed for Snap execution.
+   * @returns A string `OK` if execution succeeded.
+   * @throws If the execution service returns an error.
+   */
+  async executeSnap(snapData) {
+    if (_chunkEXN2TFDJjs.__privateGet.call(void 0, this, _snapToJobMap).has(snapData.snapId)) {
+      throw new Error(`Snap "${snapData.snapId}" is already being executed.`);
+    }
+    const job = await this.initJob();
+    _chunkEXN2TFDJjs.__privateMethod.call(void 0, this, _mapSnapAndJob, mapSnapAndJob_fn).call(this, snapData.snapId, job.id);
+    await this.command(job.id, {
+      jsonrpc: "2.0",
+      method: "ping",
+      id: _nanoid.nanoid.call(void 0, )
+    });
+    const rpcStream = job.streams.rpc;
+    this.setupSnapProvider(snapData.snapId, rpcStream);
+    const result = await this.command(job.id, {
+      jsonrpc: "2.0",
+      method: "executeSnap",
+      params: snapData,
+      id: _nanoid.nanoid.call(void 0, )
+    });
+    _chunkEXN2TFDJjs.__privateMethod.call(void 0, this, _createSnapHooks, createSnapHooks_fn).call(this, snapData.snapId, job.id);
+    return result;
+  }
+  // Cannot be hash private yet because of tests.
+  async command(jobId, message) {
+    _utils.assertIsJsonRpcRequest.call(void 0, message);
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      throw new Error(`Job with id "${jobId}" not found.`);
+    }
+    _chunk66XO4TRYjs.log.call(void 0, "Parent: Sending Command", message);
+    const response = await job.rpcEngine.handle(
+      message
+    );
+    if (response.error) {
+      throw new (0, _rpcerrors.JsonRpcError)(
+        response.error.code,
+        response.error.message,
+        response.error.data
+      );
+    }
+    return response.result;
+  }
+  /**
+   * Handle RPC request.
+   *
+   * @param snapId - The ID of the recipient snap.
+   * @param options - Bag of options to pass to the RPC handler.
+   * @returns Promise that can handle the request.
+   */
+  async handleRpcRequest(snapId, options) {
+    const rpcRequestHandler = this.getRpcRequestHandler(snapId);
+    if (!rpcRequestHandler) {
+      throw new Error(
+        `Snap execution service returned no RPC handler for running snap "${snapId}".`
+      );
+    }
+    return rpcRequestHandler(options);
+  }
+};
+_snapRpcHooks = new WeakMap();
+_snapToJobMap = new WeakMap();
+_jobToSnapMap = new WeakMap();
+_messenger = new WeakMap();
+_terminationTimeout = new WeakMap();
+_removeSnapHooks = new WeakSet();
+removeSnapHooks_fn = function(snapId) {
+  _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _snapRpcHooks).delete(snapId);
+};
+_createSnapHooks = new WeakSet();
+createSnapHooks_fn = function(snapId, workerId) {
+  const rpcHook = async ({ origin, handler, request }) => {
+    return await this.command(workerId, {
+      id: _nanoid.nanoid.call(void 0, ),
+      jsonrpc: "2.0",
+      method: "snapRpc",
+      params: {
+        origin,
+        handler,
+        request,
+        target: snapId
+      }
+    });
+  };
+  _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _snapRpcHooks).set(snapId, rpcHook);
+};
+_mapSnapAndJob = new WeakSet();
+mapSnapAndJob_fn = function(snapId, jobId) {
+  _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _snapToJobMap).set(snapId, jobId);
+  _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _jobToSnapMap).set(jobId, snapId);
+};
+_removeSnapAndJobMapping = new WeakSet();
+removeSnapAndJobMapping_fn = function(jobId) {
+  const snapId = _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _jobToSnapMap).get(jobId);
+  if (!snapId) {
+    throw new Error(`job: "${jobId}" has no mapped snap.`);
+  }
+  _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _jobToSnapMap).delete(jobId);
+  _chunkEXN2TFDJjs.__privateGet.call(void 0, this, _snapToJobMap).delete(snapId);
+  _chunkEXN2TFDJjs.__privateMethod.call(void 0, this, _removeSnapHooks, removeSnapHooks_fn).call(this, snapId);
+};
+function setupMultiplex(connectionStream, streamName) {
+  const mux = new (0, _objectmultiplex2.default)();
+  _readablestream.pipeline.call(void 0, connectionStream, mux, connectionStream, (error) => {
+    if (error) {
+      streamName ? _snapsutils.logError.call(void 0, `"${streamName}" stream failure.`, error) : _snapsutils.logError.call(void 0, error);
+    }
+  });
+  return mux;
+}
+
+
+
+
+exports.AbstractExecutionService = AbstractExecutionService; exports.setupMultiplex = setupMultiplex;
+//# sourceMappingURL=chunk-3RXU6FL7.js.map