@xyo-network/xl1-cli-lib 1.15.27 → 1.16.0

package/dist/node/commands/index.d.ts

@@ -1,5 +1,6 @@
 export * from './api/index.ts';
 export * from './bridge/index.ts';
+export * from './mempool/index.ts';
 export * from './producer/index.ts';
 export * from './rewardRedemption/index.ts';
 export * from './validator/index.ts';

package/dist/node/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,sBAAsB,CAAA"}

package/dist/node/commands/mempool/index.d.ts

@@ -0,0 +1,2 @@
+export * from './runMempool.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/commands/mempool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/mempool/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

package/dist/node/commands/mempool/runMempool.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from '@xylabs/logger';
+import type { Config } from '@xyo-network/xl1-protocol-sdk';
+interface RunMempoolContext {
+    config: Config;
+    logger?: Logger;
+}
+export declare function runMempool(context: RunMempoolContext): void;
+export {};
+//# sourceMappingURL=runMempool.d.ts.map

package/dist/node/commands/mempool/runMempool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runMempool.d.ts","sourceRoot":"","sources":["../../../../src/commands/mempool/runMempool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAE3D,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,QAEpD"}

package/dist/node/index.mjs

@@ -593,8 +593,8 @@ var createHealthServer = /* @__PURE__ */ __name((port, statusMonitor, logger) =>
   return server;
 }, "createHealthServer");
 var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
-  const { config: config3, logger, statusReporter } = params;
-  const { healthCheckPort } = config3.producer;
+  const { config: config2, logger, statusReporter } = params;
+  const { healthCheckPort } = config2.producer;
   return isDefined3(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : void 0;
 }, "initHealthEndpoints");
 
@@ -603,7 +603,6 @@ import { assertEx as assertEx18 } from "@xylabs/assert";
 import { asAddress as asAddress2 } from "@xylabs/hex";
 import { isDefined as isDefined14 } from "@xylabs/typeof";
 import { initTelemetry, startupSpanAsync as startupSpanAsync8, StepSizes, validateHydratedBlockState } from "@xyo-network/chain-sdk";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 import { readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
 import { CompletedStepRewardAddressValidatorFactory, DerivedReceiveAddressValidatorFactory, SelfSignerValidator, TransactionTransfersValidatorFactory } from "@xyo-network/xl1-validation";
 import { Semaphore as Semaphore2 } from "async-mutex";
@@ -643,10 +642,10 @@ var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeNam
 // src/orchestration/archivists/ChainFinalized/local.ts
 var mutex = new Mutex2();
 var singleton;
-var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex.runExclusive(async () => {
     if (singleton) return singleton;
-    const { root } = config3.storage;
+    const { root } = config2.storage;
     singleton = await getLocalPersistentArchivist("local-finalized-chain", "chain", "finalized", root);
     return singleton;
   });
@@ -659,10 +658,10 @@ import { getUrl } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex3 } from "async-mutex";
 var mutex2 = new Mutex3();
 var singleton2;
-var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex2.runExclusive(async () => {
     if (singleton2) return singleton2;
-    const { host, port } = config3.api;
+    const { host, port } = config2.mempool.enabled ? config2.mempool : config2.api;
     const nodeUrl = getUrl(host, port);
     const bridge = await initBridge(nodeUrl);
     singleton2 = await initBridgedArchivistModule({
@@ -676,16 +675,16 @@ var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config:
 // src/orchestration/archivists/ChainFinalized/archivist.ts
 var mutex3 = new Mutex4();
 var singleton3;
-async function initChainFinalizedArchivist({ config: config3, logger, traceProvider }) {
+async function initChainFinalizedArchivist({ config: config2, logger, traceProvider }) {
   return await mutex3.runExclusive(async () => {
     if (singleton3) return singleton3;
     const [remote, local] = await Promise.all([
       startupSpanAsync("ChainFinalizedArchivist:initRemote", () => initRemoteChainFinalizedArchivist({
-        config: config3,
+        config: config2,
         logger
       })),
       startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist({
-        config: config3,
+        config: config2,
         logger
       }))
     ]);
@@ -708,10 +707,10 @@ import { getUrl as getUrl2 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex5 } from "async-mutex";
 var mutex4 = new Mutex5();
 var singleton4;
-var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex4.runExclusive(async () => {
     if (singleton4) return singleton4;
-    const { host, port } = config3.api;
+    const { host, port } = config2.mempool.enabled ? config2.mempool : config2.api;
     const nodeUrl = getUrl2(host, port);
     const bridge = await initBridge2(nodeUrl);
     singleton4 = await initBridgedArchivistModule2({
@@ -765,10 +764,10 @@ import { getUrl as getUrl3 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex8 } from "async-mutex";
 var mutex7 = new Mutex8();
 var singleton7;
-var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex7.runExclusive(async () => {
     if (singleton7) return singleton7;
-    const { host, port } = config3.api;
+    const { host, port } = config2.mempool.enabled ? config2.mempool : config2.api;
     const nodeUrl = getUrl3(host, port);
     const bridge = await initBridge3(nodeUrl);
     singleton7 = await initBridgedArchivistModule3({
@@ -848,10 +847,10 @@ import { assertEx as assertEx9 } from "@xylabs/assert";
 import { Mutex as Mutex12 } from "async-mutex";
 var mutex11 = new Mutex12();
 var singleton11;
-var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex11.runExclusive(async () => {
     if (singleton11) return singleton11;
-    const { root } = config3.storage;
+    const { root } = config2.storage;
     singleton11 = await getLocalPersistentArchivist("local-stake-intent-state", "stakeIntent", "state", root);
     return assertEx9(singleton11, () => new Error("Failed to initialize stake intent state archivist"));
   });
@@ -940,9 +939,9 @@ import { isUndefined as isUndefined3 } from "@xylabs/typeof";
 import { HDWallet } from "@xyo-network/wallet";
 import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-protocol-sdk";
 var accountServiceSingleton;
-var initAccount = /* @__PURE__ */ __name(async ({ config: config3, logger }) => {
+var initAccount = /* @__PURE__ */ __name(async ({ config: config2, logger }) => {
   if (accountServiceSingleton) return accountServiceSingleton;
-  let walletPhrase = config3.producer.mnemonic;
+  let walletPhrase = config2.producer.mnemonic;
   if (isUndefined3(walletPhrase)) {
     logger?.warn("[Producer] No wallet mnemonic specified!");
     const randomMnemonic = HDWallet.generateMnemonic();
@@ -990,11 +989,11 @@ import { InfuraProvider } from "ethers/providers";
 import { assertEx as assertEx11 } from "@xylabs/assert";
 import { hexFrom, isHex } from "@xylabs/hex";
 import { isDefined as isDefined8 } from "@xylabs/typeof";
-var canUseChainId = /* @__PURE__ */ __name((config3) => {
-  return isDefined8(config3.evm.chainId);
+var canUseChainId = /* @__PURE__ */ __name((config2) => {
+  return isDefined8(config2.evm.chainId);
 }, "canUseChainId");
-var getChainId = /* @__PURE__ */ __name((config3) => {
-  const chainId = assertEx11(config3.evm.chainId, () => "Missing config.evm.chainId");
+var getChainId = /* @__PURE__ */ __name((config2) => {
+  const chainId = assertEx11(config2.evm.chainId, () => "Missing config.evm.chainId");
   if (isHex(chainId, {
     prefix: true
   })) {
@@ -1009,20 +1008,20 @@ var getChainId = /* @__PURE__ */ __name((config3) => {
 
 // src/orchestration/services/implementation/evm/initInfuraProvider.ts
 var instance;
-var initInfuraProvider = /* @__PURE__ */ __name((config3) => {
+var initInfuraProvider = /* @__PURE__ */ __name((config2) => {
   if (instance) return instance;
-  const providerConfig = getInfuraProviderConfig(config3);
+  const providerConfig = getInfuraProviderConfig(config2);
   instance = Promise.resolve(new InfuraProvider(...providerConfig));
   return instance;
 }, "initInfuraProvider");
-var canUseInfuraProvider = /* @__PURE__ */ __name((config3) => {
-  return canUseChainId(config3) && isDefined9(config3.evm?.infura?.projectId) && isDefined9(config3.evm?.infura?.projectSecret);
+var canUseInfuraProvider = /* @__PURE__ */ __name((config2) => {
+  return canUseChainId(config2) && isDefined9(config2.evm?.infura?.projectId) && isDefined9(config2.evm?.infura?.projectSecret);
 }, "canUseInfuraProvider");
-var getInfuraProviderConfig = /* @__PURE__ */ __name((config3) => {
-  const projectId = assertEx12(config3.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx12(config3.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+var getInfuraProviderConfig = /* @__PURE__ */ __name((config2) => {
+  const projectId = assertEx12(config2.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx12(config2.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
   return [
-    getChainId(config3),
+    getChainId(config2),
     projectId,
     projectSecret
   ];
@@ -1032,50 +1031,50 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((config3) => {
 import { assertEx as assertEx13 } from "@xylabs/assert";
 import { isDefined as isDefined10 } from "@xylabs/typeof";
 import { JsonRpcProvider } from "ethers/providers";
-var initJsonRpcProvider = /* @__PURE__ */ __name((config3) => {
-  const providerConfig = getJsonRpcProviderConfig(config3);
+var initJsonRpcProvider = /* @__PURE__ */ __name((config2) => {
+  const providerConfig = getJsonRpcProviderConfig(config2);
   return Promise.resolve(new JsonRpcProvider(...providerConfig));
 }, "initJsonRpcProvider");
-var canUseJsonRpcProvider = /* @__PURE__ */ __name((config3) => {
-  return canUseChainId(config3) && isDefined10(config3.evm.jsonRpc?.url);
+var canUseJsonRpcProvider = /* @__PURE__ */ __name((config2) => {
+  return canUseChainId(config2) && isDefined10(config2.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
-var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config3) => {
-  const jsonRpcUrl = assertEx13(config3.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config2) => {
+  const jsonRpcUrl = assertEx13(config2.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
   return [
     jsonRpcUrl,
-    getChainId(config3)
+    getChainId(config2)
   ];
 }, "getJsonRpcProviderConfig");
 
 // src/orchestration/services/implementation/evm/initEvmProvider.ts
 var provider;
-var initEvmProvider = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initEvmProvider = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   if (provider) return provider;
-  if (canUseInfuraProvider(config3)) {
-    provider = initInfuraProvider(config3);
-  } else if (canUseJsonRpcProvider(config3)) {
-    provider = initJsonRpcProvider(config3);
+  if (canUseInfuraProvider(config2)) {
+    provider = initInfuraProvider(config2);
+  } else if (canUseJsonRpcProvider(config2)) {
+    provider = initJsonRpcProvider(config2);
   }
   return assertEx14(await provider, () => "Error: No provider available");
 }, "initEvmProvider");
-var canUseEvmProvider = /* @__PURE__ */ __name(({ config: config3 }) => {
-  return canUseInfuraProvider(config3) || canUseJsonRpcProvider(config3);
+var canUseEvmProvider = /* @__PURE__ */ __name(({ config: config2 }) => {
+  return canUseInfuraProvider(config2) || canUseJsonRpcProvider(config2);
 }, "canUseEvmProvider");
 
 // src/orchestration/services/implementation/chain/evm.ts
 var chainStakeServiceSingleton;
-var canUseEvmContractChainService = /* @__PURE__ */ __name((config3) => {
-  const { id } = config3.chain;
+var canUseEvmContractChainService = /* @__PURE__ */ __name((config2) => {
+  const { id } = config2.chain;
   return isDefined11(id) && id !== ZERO_ADDRESS && canUseEvmProvider({
-    config: config3
+    config: config2
   });
 }, "canUseEvmContractChainService");
-var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, config: config3, traceProvider, meterProvider, logger }) => {
+var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, config: config2, traceProvider, meterProvider, logger }) => {
   if (chainStakeServiceSingleton) return chainStakeServiceSingleton;
-  const emvStakingContractAddress = assertEx15(config3.chain.id, () => "Error: config.chain.id is required");
+  const emvStakingContractAddress = assertEx15(config2.chain.id, () => "Error: config.chain.id is required");
   const id = assertEx15(asAddress(emvStakingContractAddress), () => "Error: config.chain.id is not a valid address");
   const provider2 = assertEx15(await initEvmProvider({
-    config: config3
+    config: config2
   }));
   const privateKey = assertEx15(account.private?.hex, () => "Error: Account does not have a private key");
   const runner = new Wallet(privateKey, provider2);
@@ -1091,15 +1090,15 @@ var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, confi
 
 // src/orchestration/services/implementation/chain/index.ts
 var chainStakeServiceSingleton2;
-var initChainService = /* @__PURE__ */ __name(({ account, config: config3 }) => init({
-  config: config3,
+var initChainService = /* @__PURE__ */ __name(({ account, config: config2 }) => init({
+  config: config2,
   name: "ChainService",
   account
 }), "initChainService");
 var init = /* @__PURE__ */ __name((params) => {
   if (chainStakeServiceSingleton2) return chainStakeServiceSingleton2;
-  const { config: config3 } = params;
-  chainStakeServiceSingleton2 = canUseEvmContractChainService(config3) ? initEvmContractChainService({
+  const { config: config2 } = params;
+  chainStakeServiceSingleton2 = canUseEvmContractChainService(config2) ? initEvmContractChainService({
     ...params,
     name: "ChainStakeService"
   }) : MemoryChainService.create({
@@ -1282,7 +1281,7 @@ var createForkedHead = /* @__PURE__ */ __name(async (forkFromBlock, account, cha
 // src/orchestration/services/implementation/head/getForkFromBlock.ts
 import { asHash, hexFromBigInt } from "@xylabs/hex";
 import { isDefined as isDefined12 } from "@xylabs/typeof";
-import { isBlockBoundWitnessWithHashStorageMeta } from "@xyo-network/chain-sdk";
+import { isBlockBoundWitnessWithHashMeta } from "@xyo-network/chain-sdk";
 var getForkFromBlock = /* @__PURE__ */ __name(async (head, chainService, chainArchivist) => {
   if (head.chain !== chainService.chainId) {
     const forkedAtBigInt = await chainService.forkedAtHash();
@@ -1294,7 +1293,7 @@ var getForkFromBlock = /* @__PURE__ */ __name(async (head, chainService, chainAr
       ]);
       const forkedChainId = await chainService.forkedChainId();
       const forkedAtBlockNumber = Number(await chainService.forkedAtBlockNumber());
-      if (isBlockBoundWitnessWithHashStorageMeta(forkedAtBlock) && forkedAtBlock.chain === forkedChainId && forkedAtBlock.block === forkedAtBlockNumber) {
+      if (isBlockBoundWitnessWithHashMeta(forkedAtBlock) && forkedAtBlock.chain === forkedChainId && forkedAtBlock.block === forkedAtBlockNumber) {
         return forkedAtBlock;
       }
     }
@@ -1387,9 +1386,9 @@ import { EvmBlockRewardService, MemoryBlockRewardService } from "@xyo-network/ch
 var rewardServiceSingleton;
 var initBlockRewardService = /* @__PURE__ */ __name((params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
-  const { config: config3 } = params;
+  const { config: config2 } = params;
   rewardServiceSingleton = canUseEvmBlockRewardService({
-    config: config3
+    config: config2
   }) ? initEvmBlockRewardService(params) : initXyoBlockRewardService(params);
   return rewardServiceSingleton;
 }, "initBlockRewardService");
@@ -1418,12 +1417,12 @@ var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
 // src/orchestration/services/implementation/time.ts
 import { BaseTimeSyncService } from "@xyo-network/chain-sdk";
 var timeSyncServiceSingleton;
-var initTimeService = /* @__PURE__ */ __name(async ({ chainArchivist, chainIterator, config: config3, logger, meterProvider, traceProvider }) => {
+var initTimeService = /* @__PURE__ */ __name(async ({ chainArchivist, chainIterator, config: config2, logger, meterProvider, traceProvider }) => {
   if (timeSyncServiceSingleton) return timeSyncServiceSingleton;
   const ethProvider = canUseEvmProvider({
-    config: config3
+    config: config2
   }) ? await initEvmProvider({
-    config: config3
+    config: config2
   }) : void 0;
   timeSyncServiceSingleton = BaseTimeSyncService.create({
     chainArchivist,
@@ -1548,7 +1547,7 @@ var isStartable = /* @__PURE__ */ __name((value) => {
   return isDefined14(value.start) && typeof value.start === "function";
 }, "isStartable");
 var initServices = /* @__PURE__ */ __name(async (context) => {
-  const { config: config3, logger } = context;
+  const { config: config2, logger } = context;
   const statusReporter = new RuntimeStatusMonitor(logger);
   statusReporter.onGlobalTransition({
     to: "started"
@@ -1565,7 +1564,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     ...context,
     statusReporter
   }));
-  const { otlpEndpoint } = config3.telemetry?.otel ?? {};
+  const { otlpEndpoint } = config2.telemetry?.otel ?? {};
   const telemetryConfig = {
     attributes: {
       serviceName: "xl1-producer",
@@ -1581,10 +1580,10 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     startupSpanAsync8("initTelemetry", () => initTelemetry(telemetryConfig)),
     startupSpanAsync8("initAccount", () => initAccount(context))
   ]);
-  const allowedRewardRedeemers = config3.validation?.allowedRewardRedeemers ?? [];
-  const allowedRewardEscrowAccountSigners = config3.validation?.allowedRewardEscrowAccountSigners ?? [];
+  const allowedRewardRedeemers = config2.validation?.allowedRewardRedeemers ?? [];
+  const allowedRewardEscrowAccountSigners = config2.validation?.allowedRewardEscrowAccountSigners ?? [];
   const initParams = {
-    config: config3,
+    config: config2,
     logger,
     meterProvider,
     statusReporter,
@@ -1654,7 +1653,13 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
         store: {
           chainMap
         },
-        head: /* @__PURE__ */ __name(async () => PayloadBuilder7.hash(await chainIterator.head()), "head"),
+        head: /* @__PURE__ */ __name(async () => {
+          const head2 = await chainIterator.head();
+          return [
+            head2._hash,
+            head2.block
+          ];
+        }, "head"),
         chainId,
         summaryMap: balanceSummaryMap
       },
@@ -1667,7 +1672,13 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
         store: {
           chainMap
         },
-        head: /* @__PURE__ */ __name(async () => PayloadBuilder7.hash(await chainIterator.head()), "head"),
+        head: /* @__PURE__ */ __name(async () => {
+          const head2 = await chainIterator.head();
+          return [
+            head2._hash,
+            head2.block
+          ];
+        }, "head"),
         chainId,
         summaryMap: transferSummaryMap
       },
@@ -1709,7 +1720,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     validateHydratedBlockState,
     ...initParams
   };
-  const rewardAddress = isDefined14(config3.producer.rewardAddress) ? assertEx18(asAddress2(config3.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
+  const rewardAddress = isDefined14(config2.producer.rewardAddress) ? assertEx18(asAddress2(config2.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
   const producerParams = {
     ...validatorParams,
     name: "Producer",
@@ -1771,15 +1782,22 @@ function runBridge(context) {
 }
 __name(runBridge, "runBridge");
 
+// src/commands/mempool/runMempool.ts
+import { getServer as getServer3 } from "@xyo-network/chain-head-reducer";
+function runMempool(context) {
+  void getServer3(context);
+}
+__name(runMempool, "runMempool");
+
 // src/commands/producer/runProducer.ts
 var runProducer = /* @__PURE__ */ __name(async (context) => {
-  const { config: config3, logger, orchestrator } = context;
+  const { config: config2, logger, orchestrator } = context;
   logger?.log("Services: Initializing...");
   const services = await initServices(context);
   logger?.log("Services: Initialized");
   const params = {
     ...services,
-    config: config3
+    config: config2
   };
   const chainHeadUpdate = await ChainHeadUpdateActor.create(params);
   const balances = await BalanceActor.create(params);
@@ -1796,9 +1814,9 @@ var runProducer = /* @__PURE__ */ __name(async (context) => {
 }, "runProducer");
 
 // src/commands/rewardRedemption/runRewardRedemptionApi.ts
-import { getServer as getServer3 } from "@xyo-network/chain-reward-redemption";
+import { getServer as getServer4 } from "@xyo-network/chain-reward-redemption";
 function runRewardRedemptionApi(context) {
-  void getServer3(context);
+  void getServer4(context);
 }
 __name(runRewardRedemptionApi, "runRewardRedemptionApi");
 
@@ -1826,14 +1844,14 @@ var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\
 import { Base as Base2 } from "@xylabs/base";
 import { ConsoleLogger, LogLevel, SilentLogger } from "@xylabs/logger";
 import { isDefined as isDefined15 } from "@xylabs/typeof";
-var initLogger = /* @__PURE__ */ __name((config3) => {
+var initLogger = /* @__PURE__ */ __name((config2) => {
   let logger;
-  if (config3.silent) {
+  if (config2.silent) {
     logger = new SilentLogger();
   } else {
     let level;
-    if (isDefined15(config3.logLevel)) {
-      const parsed = LogLevel[config3.logLevel.toLowerCase()];
+    if (isDefined15(config2.logLevel)) {
+      const parsed = LogLevel[config2.logLevel.toLowerCase()];
       if (isDefined15(parsed)) level = parsed;
     }
     logger = new ConsoleLogger(level);
@@ -1898,10 +1916,10 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 }, "waitForHostPort");
 
 // src/runCLI.ts
-var config;
-var version = isDefined17("1.15.26") ? "1.15.26" : "unknown";
-var getContextFromConfig = /* @__PURE__ */ __name((config3) => {
-  const logger = initLogger(config3);
+var configuration;
+var version = isDefined17("1.15.28") ? "1.15.28" : "unknown";
+var getContextFromConfig = /* @__PURE__ */ __name((configuration2) => {
+  const logger = initLogger(configuration2);
   const orchestrator = new Orchestrator(logger);
   process.on("SIGINT", () => {
     void (async () => {
@@ -1938,7 +1956,7 @@ $0 <command> [options]`).parserConfiguration({
       const parsedConfigFile = tryParseConfig();
       const parsedConfigArgs = argv2;
       const mergedConfig = deepMerge(parsedConfigArgs, parsedConfigFile);
-      config = ConfigZod.parse(mergedConfig);
+      configuration = ConfigZod.parse(mergedConfig);
     } catch (err) {
       if (err instanceof ZodError) {
         console.error(`${err.message}`);
@@ -1948,50 +1966,66 @@ $0 <command> [options]`).parserConfiguration({
   }).options(optionsFromGlobalZodRegistry()).wrap(y.terminalWidth()).command("api", "Run a XL1 API Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 API Node", () => {
     }, () => {
-      const context = getContextFromConfig(config);
+      const context = getContextFromConfig(configuration);
       runApi({
         ...context,
-        config
+        config: configuration
       });
     });
   }).command("bridge", "Run a XL1 Bridge Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Bridge Node", () => {
     }, () => {
-      const context = getContextFromConfig(config);
+      const context = getContextFromConfig(configuration);
       runBridge({
         ...context,
-        config
+        config: configuration
+      });
+    });
+  }).command("mempool", "Run a XL1 Mempool Node", (yargs2) => {
+    return yargs2.command("$0", "Run a XL1 Mempool Node", () => {
+    }, () => {
+      const context = getContextFromConfig(configuration);
+      runMempool({
+        ...context,
+        config: configuration
       });
     });
   }).command("producer", "Run a XL1 Producer Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Producer Node", () => {
     }, async () => {
-      const context = getContextFromConfig(config);
+      const context = getContextFromConfig(configuration);
       await runProducer({
         ...context,
-        config
+        config: configuration
       });
     });
   }).command("reward-redemption-api", "Run a XL1 Rewards Redemption API Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Rewards Redemption API Node", () => {
     }, () => {
-      const context = getContextFromConfig(config);
+      const context = getContextFromConfig(configuration);
       runRewardRedemptionApi({
         ...context,
-        config
+        config: configuration
       });
     });
   }).command("$0", "Run a full XL1 Node", () => {
   }, async () => {
-    const context = getContextFromConfig(config);
+    const context = getContextFromConfig(configuration);
+    if (configuration.mempool.enabled) {
+      runMempool({
+        ...context,
+        config: configuration
+      });
+      await waitForHostPort(configuration.mempool.host, configuration.mempool.port);
+    }
     runApi({
       ...context,
-      config
+      config: configuration
     });
-    await waitForHostPort("localhost", config.api.port);
+    await waitForHostPort(configuration.api.host, configuration.api.port);
     await runProducer({
       ...context,
-      config
+      config: configuration
     });
   }).help().alias("help", "h").version(version).argv;
   await argv;
@@ -1999,9 +2033,9 @@ $0 <command> [options]`).parserConfiguration({
 __name(runCLI, "runCLI");
 
 // src/start.ts
-import { config as config2 } from "dotenv";
+import { config } from "dotenv";
 var start = /* @__PURE__ */ __name(async () => {
-  config2({
+  config({
     quiet: true
   });
   await runCLI();