@xyo-network/chain-orchestration 1.19.3 → 1.19.5

package/dist/neutral/index.mjs

@@ -10,8 +10,8 @@ var BalanceActor = class extends Actor {
     __name(this, "BalanceActor");
   }
   _updateMutex = new Mutex();
-  get balanceService() {
-    return assertEx(this.params.balance, () => "balanceService not set");
+  get accountBalanceViewer() {
+    return assertEx(this.params.accountBalanceViewer, () => "balanceService not set");
   }
   get blockViewer() {
     return assertEx(this.params.blockViewer, () => "blockViewer not set");
@@ -32,18 +32,17 @@ var BalanceActor = class extends Actor {
     if (this._updateMutex.isLocked()) return;
     await this._updateMutex.runExclusive(async () => {
       const head = await this.blockViewer.currentBlockHash();
-      await this.balanceService.accountBalances([], {
+      await this.accountBalanceViewer.accountBalances([], {
         head
       });
     });
   }
 };
 
-// src/actor/ValidatorActor.ts
+// src/actor/MempoolActor.ts
 import { assertEx as assertEx2, creatable } from "@xylabs/sdk-js";
-import { processPendingBlocks } from "@xyo-network/chain-sdk";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { Actor as Actor2, BlockViewerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
+import { Actor as Actor2 } from "@xyo-network/xl1-sdk";
+import { Mutex as Mutex2 } from "async-mutex";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -51,27 +50,117 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
-var ValidatorActor = class extends Actor2 {
+var MempoolActor = class extends Actor2 {
+  static {
+    __name(this, "MempoolActor");
+  }
+  _blockTimerId = null;
+  _blockTimerMutex = new Mutex2();
+  _transactionTimerId = null;
+  _transactionTimerMutex = new Mutex2();
+  get mempoolRunner() {
+    return this.params.mempoolRunner;
+  }
+  get pendingBlocksArchivist() {
+    return this.params.pendingBlocksArchivist;
+  }
+  get pendingTransactionsArchivist() {
+    return this.params.pendingTransactionsArchivist;
+  }
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      mempoolRunner: assertEx2(params?.mempoolRunner, () => "mempoolRunner is required for MempoolActor"),
+      pendingBlocksArchivist: assertEx2(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required for MempoolActor"),
+      pendingTransactionsArchivist: assertEx2(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required for MempoolActor")
+    };
+  }
+  async startHandler() {
+    await super.startHandler();
+    this.restartBlockTimer();
+  }
+  async stopHandler() {
+    await super.stopHandler();
+    this.stopBlockTimer();
+  }
+  restartBlockTimer() {
+    this.stopBlockTimer();
+    this._blockTimerId = setInterval(() => {
+      if (this._blockTimerMutex.isLocked()) {
+        return;
+      }
+      void this._blockTimerMutex.runExclusive(async () => {
+        await this.mempoolRunner.prunePendingBlocks({
+          batchSize: 50
+        });
+      });
+    }, 1e3);
+  }
+  restartTransactionTimer() {
+    this.stopTransactionTimer();
+    this._transactionTimerId = setInterval(() => {
+      if (this._transactionTimerMutex.isLocked()) {
+        return;
+      }
+      void this._transactionTimerMutex.runExclusive(async () => {
+        await this.mempoolRunner.prunePendingTransactions({
+          batchSize: 50
+        });
+      });
+    }, 1e3);
+  }
+  stopBlockTimer() {
+    if (this._blockTimerId !== null) {
+      clearInterval(this._blockTimerId);
+    }
+    this._blockTimerId = null;
+  }
+  stopTransactionTimer() {
+    if (this._transactionTimerId !== null) {
+      clearInterval(this._transactionTimerId);
+    }
+    this._transactionTimerId = null;
+  }
+};
+MempoolActor = _ts_decorate([
+  creatable()
+], MempoolActor);
+
+// src/actor/ValidatorActor.ts
+import { assertEx as assertEx3, creatable as creatable2 } from "@xylabs/sdk-js";
+import { processPendingBlocks } from "@xyo-network/chain-sdk";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { Actor as Actor3 } from "@xyo-network/xl1-sdk";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var ValidatorActor = class extends Actor3 {
   static {
     __name(this, "ValidatorActor");
   }
-  _blockViewer;
   _lastValidatedBlock;
   _lastValidatedBlockHash;
-  _mempoolViewer;
   get blockViewer() {
-    return this._blockViewer;
+    return this.params.blockViewer;
   }
   get finalizedArchivist() {
-    return assertEx2(this.params.finalizedArchivist, () => "finalizedArchivist not set");
+    return assertEx3(this.params.finalizedArchivist, () => "finalizedArchivist not set");
   }
   get mempoolViewer() {
-    return this._mempoolViewer;
+    return this.params.mempoolViewer;
   }
-  async createHandler() {
-    await super.createHandler();
-    this._blockViewer = assertEx2(this.params.blockViewer ?? await this.locator?.getInstance(BlockViewerMoniker), () => "Unable to locate a BlockViewer");
-    this._mempoolViewer = assertEx2(this.params.mempoolViewer ?? await this.locator?.getInstance(MempoolViewerMoniker), () => "Unable to locate a MempoolViewer");
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      mempoolViewer: assertEx3(params?.mempoolViewer, () => "mempoolViewer is required for ValidatorActor"),
+      blockViewer: assertEx3(params?.blockViewer, () => "blockViewer is required for ValidatorActor"),
+      finalizedArchivist: assertEx3(params?.finalizedArchivist, () => "finalizedArchivist is required for ValidatorActor"),
+      account: assertEx3(params?.account, () => "account is required for ValidatorActor")
+    };
   }
   async startHandler() {
     await super.startHandler();
@@ -108,17 +197,17 @@ var ValidatorActor = class extends Actor2 {
     return valid;
   }
 };
-ValidatorActor = _ts_decorate([
-  creatable()
+ValidatorActor = _ts_decorate2([
+  creatable2()
 ], ValidatorActor);
 
 // src/archivists/ChainFinalized/archivist.ts
 import { startupSpanAsync } from "@xyo-network/chain-utils";
 import { timeBudget } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex3 } from "async-mutex";
+import { Mutex as Mutex4 } from "async-mutex";
 
 // src/archivists/ChainFinalized/local.ts
-import { Mutex as Mutex2 } from "async-mutex";
+import { Mutex as Mutex3 } from "async-mutex";
 
 // src/archivists/lib/localPersistentArchivist.ts
 import { rm } from "fs/promises";
@@ -146,7 +235,7 @@ var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeNam
 }, "getLocalPersistentArchivist");
 
 // src/archivists/ChainFinalized/local.ts
-var mutex = new Mutex2();
+var mutex = new Mutex3();
 var singleton;
 var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config }) => {
   return await mutex.runExclusive(async () => {
@@ -158,7 +247,7 @@ var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config })
 }, "initLocalChainFinalizedArchivist");
 
 // src/archivists/ChainFinalized/archivist.ts
-var mutex2 = new Mutex3();
+var mutex2 = new Mutex4();
 var singleton2;
 async function initChainFinalizedArchivist(context) {
   return await mutex2.runExclusive(async () => {
@@ -175,11 +264,11 @@ __name(initChainFinalizedArchivist, "initChainFinalizedArchivist");
 // src/archivists/PendingBlocks/archivist.ts
 import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
 import { timeBudget as timeBudget2 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex5 } from "async-mutex";
+import { Mutex as Mutex6 } from "async-mutex";
 
 // src/archivists/PendingBlocks/local.ts
-import { Mutex as Mutex4 } from "async-mutex";
-var mutex3 = new Mutex4();
+import { Mutex as Mutex5 } from "async-mutex";
+var mutex3 = new Mutex5();
 var singleton3;
 var initLocalPendingBlocksArchivist = /* @__PURE__ */ __name(async ({ config }) => {
   return await mutex3.runExclusive(async () => {
@@ -191,7 +280,7 @@ var initLocalPendingBlocksArchivist = /* @__PURE__ */ __name(async ({ config })
 }, "initLocalPendingBlocksArchivist");
 
 // src/archivists/PendingBlocks/archivist.ts
-var mutex4 = new Mutex5();
+var mutex4 = new Mutex6();
 var singleton4;
 async function initPendingBlocksArchivist(context) {
   return await mutex4.runExclusive(async () => {
@@ -208,12 +297,12 @@ __name(initPendingBlocksArchivist, "initPendingBlocksArchivist");
 // src/archivists/RejectedTransactions/archivist.ts
 import { startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-utils";
 import { timeBudget as timeBudget3 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex7 } from "async-mutex";
+import { Mutex as Mutex8 } from "async-mutex";
 
 // src/archivists/RejectedTransactions/local.ts
 import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
-import { Mutex as Mutex6 } from "async-mutex";
-var mutex5 = new Mutex6();
+import { Mutex as Mutex7 } from "async-mutex";
+var mutex5 = new Mutex7();
 var singleton5;
 var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
   return await mutex5.runExclusive(async () => {
@@ -231,7 +320,7 @@ var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () =>
 }, "initLocalRejectedTransactionsArchivist");
 
 // src/archivists/RejectedTransactions/archivist.ts
-var mutex6 = new Mutex7();
+var mutex6 = new Mutex8();
 var singleton6;
 async function initRejectedTransactionsArchivist(params) {
   return await mutex6.runExclusive(async () => {
@@ -246,27 +335,27 @@ async function initRejectedTransactionsArchivist(params) {
 __name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
 
 // src/archivists/StakeIntentState/archivist.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
 import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
 import { timeBudget as timeBudget4 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex9 } from "async-mutex";
+import { Mutex as Mutex10 } from "async-mutex";
 
 // src/archivists/StakeIntentState/local.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
-import { Mutex as Mutex8 } from "async-mutex";
-var mutex7 = new Mutex8();
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { Mutex as Mutex9 } from "async-mutex";
+var mutex7 = new Mutex9();
 var singleton7;
 var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config }) => {
   return await mutex7.runExclusive(async () => {
     if (singleton7) return singleton7;
     const { root } = config.storage;
     singleton7 = await getLocalPersistentArchivist("local-stake-intent-state", "stakeIntent", "state", root);
-    return assertEx3(singleton7, () => new Error("Failed to initialize stake intent state archivist"));
+    return assertEx4(singleton7, () => new Error("Failed to initialize stake intent state archivist"));
   });
 }, "initLocalStakeIntentStateArchivist");
 
 // src/archivists/StakeIntentState/archivist.ts
-var mutex8 = new Mutex9();
+var mutex8 = new Mutex10();
 var singleton8;
 var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (context) => {
   return await mutex8.runExclusive(async () => {
@@ -274,7 +363,7 @@ var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (context) => {
     return await timeBudget4("initStakeIntentStateArchivist", context.logger, async () => {
       const local = await startupSpanAsync4("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(context));
       singleton8 = local;
-      return assertEx4(singleton8, () => "StakeIntentStateArchivist is undefined");
+      return assertEx5(singleton8, () => "StakeIntentStateArchivist is undefined");
     }, 2e3, true);
   });
 }, "initStakeIntentStateArchivist");
@@ -312,19 +401,19 @@ async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, r
 __name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
 
 // src/evm/initEvmProvider.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
 
 // src/evm/initInfuraProvider.ts
-import { assertEx as assertEx6, isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7, isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { InfuraProvider } from "ethers/providers";
 
 // src/evm/initChainId.ts
-import { assertEx as assertEx5, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx6, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
 var canUseChainId = /* @__PURE__ */ __name((config) => {
   return isDefined(config.evm.chainId);
 }, "canUseChainId");
 var getChainId = /* @__PURE__ */ __name((config) => {
-  const chainId = assertEx5(config.evm.chainId, () => "Missing config.evm.chainId");
+  const chainId = assertEx6(config.evm.chainId, () => "Missing config.evm.chainId");
   if (isHex(chainId, {
     prefix: true
   })) {
@@ -349,8 +438,8 @@ var canUseInfuraProvider = /* @__PURE__ */ __name((config) => {
   return canUseChainId(config) && isDefined2(config.evm?.infura?.projectId) && isDefined2(config.evm?.infura?.projectSecret);
 }, "canUseInfuraProvider");
 var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
-  const projectId = assertEx6(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx6(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  const projectId = assertEx7(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx7(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
   return [
     getChainId(config),
     projectId,
@@ -359,7 +448,7 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
 }, "getInfuraProviderConfig");
 
 // src/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx7, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8, isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { JsonRpcProvider } from "ethers/providers";
 var initJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   const providerConfig = getJsonRpcProviderConfig(config);
@@ -369,7 +458,7 @@ var canUseJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   return canUseChainId(config) && isDefined3(config.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
 var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config) => {
-  const jsonRpcUrl = assertEx7(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  const jsonRpcUrl = assertEx8(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
   return [
     jsonRpcUrl,
     getChainId(config)
@@ -385,7 +474,7 @@ var initEvmProvider = /* @__PURE__ */ __name(async ({ config }) => {
   } else if (canUseJsonRpcProvider(config)) {
     provider = initJsonRpcProvider(config);
   }
-  return assertEx8(await provider, () => "No provider available");
+  return assertEx9(await provider, () => "No provider available");
 }, "initEvmProvider");
 var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
@@ -488,7 +577,7 @@ var ServiceLifetime = {
 
 // src/init/initBalanceSummaryMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10 } from "@xylabs/sdk-js";
 import { MongoMap } from "@xyo-network/chain-protocol";
 import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-sdk";
 async function initBalanceSummaryMap({ config, logger }) {
@@ -513,7 +602,7 @@ async function initBalanceSummaryMap({ config, logger }) {
         maxEntries: 5e3
       }
     });
-    assertEx9(await result.start(), () => "Failed to start transfer summary map");
+    assertEx10(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
@@ -523,18 +612,18 @@ async function initBalanceSummaryMap({ config, logger }) {
 __name(initBalanceSummaryMap, "initBalanceSummaryMap");
 
 // src/init/initBridgedModule.ts
-import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
 import { asAttachableArchivistInstance } from "@xyo-network/archivist-model";
 import { asAttachableModuleInstance } from "@xyo-network/module-model";
-import { Mutex as Mutex10 } from "async-mutex";
-var initMutex = new Mutex10();
+import { Mutex as Mutex11 } from "async-mutex";
+var initMutex = new Mutex11();
 var bridgedModuleDictionary = {};
 var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
   return await initMutex.runExclusive(async () => {
     const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
     if (existing) return existing;
-    const mod = assertEx10(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
-    const moduleInstance = assertEx10(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    const mod = assertEx11(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
+    const moduleInstance = assertEx11(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
     let moduleMap = bridgedModuleDictionary[bridge.address];
     if (moduleMap === void 0) {
       moduleMap = {};
@@ -545,15 +634,15 @@ var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) =>
   });
 }, "initBridgedModule");
 var initBridgedArchivistModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
-  return assertEx10(asAttachableArchivistInstance(await initBridgedModule({
+  return assertEx11(asAttachableArchivistInstance(await initBridgedModule({
     bridge,
     moduleName
   })), () => `Could not convert ${moduleName} to attachable archivist instance`);
 }, "initBridgedArchivistModule");
 
 // src/init/initChainStakeViewer.ts
-import { asAddress, assertEx as assertEx11, toAddress, toEthAddress } from "@xylabs/sdk-js";
-import { EthereumChainStakeEventsViewer, EthereumChainStakeViewer } from "@xyo-network/chain-sdk";
+import { asAddress, assertEx as assertEx12, toAddress, toEthAddress } from "@xylabs/sdk-js";
+import { EvmStakeEventsViewer, EvmStakeViewer } from "@xyo-network/chain-sdk";
 import { IStakedXyoChain__factory } from "@xyo-network/typechain";
 import { SimpleStakeViewer } from "@xyo-network/xl1-sdk";
 async function initEvmChainStakeViewer(context, config, logger) {
@@ -561,21 +650,21 @@ async function initEvmChainStakeViewer(context, config, logger) {
     config,
     logger
   });
-  const contractAddress = assertEx11(config.chain.id, () => "Missing config.evm.chainId");
+  const contractAddress = assertEx12(config.chain.id, () => "Missing config.evm.chainId");
   const contract = IStakedXyoChain__factory.connect(toEthAddress(contractAddress), provider2);
-  const stakeEventsViewer = await EthereumChainStakeEventsViewer.create({
+  const stakeEventsViewer = await EvmStakeEventsViewer.create({
     contract,
     logger,
     context
   });
-  assertEx11(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
-  const stakeChainViewer = await EthereumChainStakeViewer.create({
+  assertEx12(await stakeEventsViewer.start(), () => "Failed to start EvmStakeEvents reader");
+  const stakeChainViewer = await EvmStakeViewer.create({
     contract,
     stakeEventsViewer,
     logger,
     context
   });
-  assertEx11(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
+  assertEx12(await stakeChainViewer.start(), () => "Failed to start EvmStake viewer");
   return stakeChainViewer;
 }
 __name(initEvmChainStakeViewer, "initEvmChainStakeViewer");
@@ -586,7 +675,7 @@ async function initSimpleStakeViewer(context, config, logger) {
     logger,
     positions: []
   });
-  assertEx11(await stakeViewer.start(), () => "Failed to start SimpleChainStake viewer");
+  assertEx12(await stakeViewer.start(), () => "Failed to start SimpleChainStake viewer");
   return stakeViewer;
 }
 __name(initSimpleStakeViewer, "initSimpleStakeViewer");
@@ -645,7 +734,7 @@ ${randomMnemonic}
 }, "initProducerAccount");
 
 // src/init/initSeedPhrase.ts
-import { assertEx as assertEx12, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx13, isString } from "@xylabs/sdk-js";
 import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
 async function initSeedPhrase({ config, logger, bios }) {
   const storedSeedPhrase = await bios.seedPhraseStore.get("os");
@@ -665,12 +754,12 @@ async function initSeedPhrase({ config, logger, bios }) {
     }
     await bios.seedPhraseStore.set("os", seedPhrase);
   }
-  return assertEx12(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+  return assertEx13(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }
 __name(initSeedPhrase, "initSeedPhrase");
 
 // src/init/initServerNode.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+import { assertEx as assertEx14 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 
 // src/manifest/getLocator.ts
@@ -906,7 +995,7 @@ async function writableChainArchivistFromNode(node) {
 }
 __name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
 async function readonlyChainArchivistFromNode(node) {
-  return assertEx13(asArchivistInstance(await node.resolve("Chain:Validated"), {
+  return assertEx14(asArchivistInstance(await node.resolve("Chain:Validated"), {
     required: true
   }));
 }
@@ -931,7 +1020,7 @@ async function initServerNode({ wallet, logger, config, node: providedNode, tran
     transfersSummaryMap,
     balancesSummaryMap
   });
-  assertEx13(await node.start(), () => "Failed to start node");
+  assertEx14(await node.start(), () => "Failed to start node");
   const writableChainArchivist = await writableChainArchivistFromNode(node);
   const readonlyChainArchivist = await readonlyChainArchivistFromNode(node);
   const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node);
@@ -967,7 +1056,7 @@ __name(initStatusReporter, "initStatusReporter");
 
 // src/init/initTransferSummaryMap.ts
 import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx15 } from "@xylabs/sdk-js";
 import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol";
 import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-sdk";
 async function initTransferSummaryMap({ config, logger }) {
@@ -992,7 +1081,7 @@ async function initTransferSummaryMap({ config, logger }) {
         maxEntries: 5e3
       }
     });
-    assertEx14(await result.start(), () => "Failed to start transfer summary map");
+    assertEx15(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
@@ -1049,14 +1138,14 @@ async function initRewardsRedemptionApiWallet({ config, logger }) {
 __name(initRewardsRedemptionApiWallet, "initRewardsRedemptionApiWallet");
 
 // src/orchestrator/Orchestrator.ts
-import { AbstractCreatable, creatable as creatable2 } from "@xylabs/sdk-js";
-function _ts_decorate2(decorators, target, key, desc) {
+import { AbstractCreatable, creatable as creatable3 } from "@xylabs/sdk-js";
+function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate2, "_ts_decorate");
+__name(_ts_decorate3, "_ts_decorate");
 var Orchestrator = class extends AbstractCreatable {
   static {
     __name(this, "Orchestrator");
@@ -1109,13 +1198,14 @@ var Orchestrator = class extends AbstractCreatable {
     this.logger?.log("[Orchestrator] Stopped...");
   }
 };
-Orchestrator = _ts_decorate2([
-  creatable2()
+Orchestrator = _ts_decorate3([
+  creatable3()
 ], Orchestrator);
 export {
   BalanceActor,
   DefaultServiceProvider,
   GenericHost,
+  MempoolActor,
   NodeManifest,
   Orchestrator,
   PrivateChildManifests,