@xyo-network/xl1-cli 1.19.2 → 1.19.4

package/dist/cli-min.mjs

@@ -85431,14 +85431,16 @@ var SingleTimeConfigZod = union$1([
   object$4({ months: timeUnitSchema }),
   object$4({ years: timeUnitSchema })
 ]).describe("Time configuration with exactly one time unit");
-tuple([
+var HydratedBlockZod = tuple([
   BlockBoundWitnessZod,
   array$1(PayloadZodLoose)
 ]);
-tuple([
+var isHydratedBlock = zodIsFactory(HydratedBlockZod);
+var HydratedBlockWithHashMetaZod = tuple([
   WithHashMetaZod(BlockBoundWitnessZod),
   array$1(WithHashMetaZod(PayloadZodLoose))
 ]);
+var isHydratedBlockWithHashMeta = zodIsFactory(HydratedBlockWithHashMetaZod);
 tuple([
   WithStorageMetaZod(BlockBoundWitnessZod),
   array$1(WithStorageMetaZod(PayloadZodLoose))
@@ -86236,14 +86238,10 @@ var ProviderFactory = class _ProviderFactory {
   static withParams(creatableProvider2, dependencies, params, labels = {}) {
     return new _ProviderFactory(creatableProvider2, dependencies, params, labels);
   }
-  /** @deprecated use getInstance instead */
-  async create(params, start = true) {
-    return await this.getInstance(params, start);
-  }
   factory(dependencies, params, labels = {}) {
     return new _ProviderFactory(this.creatableProvider, dependencies, params, labels);
   }
-  async getInstance(params, start = true) {
+  async getInstance(params, { start = true }) {
     let scopeObject = {};
     switch (this.scope) {
       case "global": {
@@ -86289,9 +86287,9 @@ var ProviderFactory = class _ProviderFactory {
     }
     return result;
   }
-  async tryGetInstance(params, start = true) {
+  async tryGetInstance(params, options) {
     try {
-      return await this.getInstance(params, start);
+      return await this.getInstance(params, options);
     } catch {
       return;
     }
@@ -86342,7 +86340,10 @@ var AbstractCreatableProvider = class extends AbstractCreatable {
     }
   }
   async locateAndCreate(moniker) {
-    return await this.locator?.getInstance(moniker);
+    return await this.locator.getInstance(moniker);
+  }
+  async tryLocateAndCreate(moniker) {
+    return await this.locator.tryGetInstance(moniker);
   }
 };
 
@@ -86354,8 +86355,6 @@ function creatableProvider() {
 var buildProviderFactory = (provider, labels) => {
   const factory = {
     monikers: provider.monikers,
-    // Copy static methods
-    create: provider.create.bind(provider),
     // Merge module & supplied labels
     labels: { ...provider.labels, ...labels },
     creatableProvider: provider.creatableProvider,
@@ -86426,14 +86425,10 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
   static standard(context) {
     return new _ProviderFactoryLocator(context, {});
   }
-  /** @deprecated use getInstance instead */
-  async create(moniker, params, labels) {
-    return await this.getInstance(moniker, params, labels);
-  }
   freeze() {
     this._frozen = true;
   }
-  async getInstance(moniker, params, labels) {
+  async getInstance(moniker, params, { start = true, labels } = {}) {
     const resolvedParams = {
       ...params,
       context: {
@@ -86442,7 +86437,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
       }
     };
     const factory = this.locate(moniker, labels);
-    const result = await factory.getInstance(resolvedParams);
+    const result = await factory.getInstance(resolvedParams, { start });
     return result;
   }
   /**
@@ -86488,9 +86483,9 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
     }
     return this;
   }
-  async tryGetInstance(moniker, params, labels) {
+  async tryGetInstance(moniker, params, options) {
     try {
-      return await this.getInstance(moniker, params, labels);
+      return await this.getInstance(moniker, params, options);
     } catch {
       return;
     }
@@ -88624,11 +88619,13 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
     this._chainContractViewer = await this.locator.getInstance(ChainContractViewerMoniker);
   }
   async qualifiedValidateBlock(block, config) {
-    return await this.qualifiedValidateBlocks([block], config);
+    const result = await this.qualifiedValidateBlocks([block], config);
+    return [result[0][0], result[1]];
   }
   async qualifiedValidateBlocks(blocks, config) {
     const { value, state } = config ?? {
       state: true};
+    const blocksWithMeta = await Promise.all(blocks.map((b) => Promise.all([PayloadBuilder.addHashMeta(b[0]), PayloadBuilder.addHashMeta(b[1])])));
     const head = isChainQualifiedHeadConfig(config) ? assertEx(
       (await this.blockViewer.blockByHash(config.head))?.[0],
       () => `Specified a head that is not in the chain [${config.head}]`
@@ -88637,25 +88634,44 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
     const validateProtocol = value ? this.doValidateProtocol.bind(this) : void 0;
     const validateState = state ? this.doValidateState.bind(this) : void 0;
     const chainIdAtBlockNumber = (blockNumber) => this.chainContractViewer.chainIdAtBlockNumber(blockNumber);
-    return [(await Promise.all([
-      validateProtocol?.(blocks, chainIdAtBlockNumber),
-      validateState?.(blocks, chainIdAtBlockNumber)
-    ].filter(exists$2))).flat(), { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }];
+    const qualification = { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) };
+    const [protocolResults, stateResults] = await Promise.all([
+      validateProtocol?.(blocksWithMeta, chainIdAtBlockNumber),
+      validateState?.(blocksWithMeta, chainIdAtBlockNumber)
+    ]);
+    const blockResults = blocksWithMeta.map((r, i) => {
+      const errors = [];
+      if (protocolResults && !isHydratedBlock(protocolResults[i])) {
+        errors.push(...protocolResults[i]);
+      }
+      if (stateResults && !isHydratedBlock(stateResults[i])) {
+        errors.push(...stateResults[i]);
+      }
+      return errors.length === 0 ? r : errors;
+    });
+    return [blockResults, qualification];
+  }
+  qualifiedValidateUncle(_blocks, _config) {
+    throw new Error("Method not implemented.");
   }
   async validateBlock(block, config) {
-    return await this.validateBlocks([block], config);
+    return (await this.validateBlocks([block], config))[0];
   }
   async validateBlocks(blocks, config) {
     return (await this.qualifiedValidateBlocks(blocks, config))[0];
   }
+  async validateUncle(blocks, config) {
+    return (await this.qualifiedValidateUncle(blocks, config))[0];
+  }
   async doValidateProtocol(blocks, chainIdAtBlockNumber) {
-    return (await Promise.all(blocks.map(async (block) => {
-      return await this.params.protocol(
+    return await Promise.all(blocks.map(async (block) => {
+      const errors = await this.params.protocol(
         this.context,
         block,
         chainIdAtBlockNumber
       );
-    }))).flat();
+      return errors.length === 0 ? block : errors;
+    }));
   }
   async doValidateState(blocks, chainIdAtBlockNumber) {
     const windowedUncleChain = await this.updateWindowedChainCache();
@@ -88665,14 +88681,15 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
       this.logger?.warn(JSON.stringify(windowedUncleChain, null, 2));
       throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}, ${blocks.length}]`);
     }
-    return (await Promise.all(uncles[0].map(async (block) => {
-      return await this.params.state(
+    return await Promise.all(uncles[0].map(async (block) => {
+      const errors = await this.params.state(
         this.context,
         block,
         chainIdAtBlockNumber,
         { accountBalance: this._accountBalanceViewer }
       );
-    }))).flat();
+      return errors.length === 0 ? block : errors;
+    }));
   }
   async updateWindowedChainCache() {
     this._uncleWindowedChainCache = await getWindowedChain(this.context, this.blockViewer, this.maxUncleWindowSize, this._uncleWindowedChainCache ?? []);
@@ -89104,6 +89121,18 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
 };
 var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   moniker = SimpleMempoolRunner.defaultMoniker;
+  _blockValidationViewer;
+  _chainContractViewer;
+  _finalizationViewer;
+  get blockValidationViewer() {
+    return this._blockValidationViewer;
+  }
+  get chainContractViewer() {
+    return this._chainContractViewer;
+  }
+  get finalizationViewer() {
+    return this._finalizationViewer;
+  }
   get pendingBlocksArchivist() {
     return this.params.pendingBlocksArchivist;
   }
@@ -89117,6 +89146,72 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       pendingTransactionsArchivist: assertEx(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required")
     };
   }
+  async createHandler() {
+    await super.createHandler();
+    this._blockValidationViewer = await this.locator.getInstance(BlockValidationViewerMoniker);
+    this._chainContractViewer = await this.locator.getInstance(ChainContractViewerMoniker);
+    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker);
+  }
+  async prunePendingBlocks({
+    batchSize = 10,
+    maxPrune = 1e3,
+    maxCheck = 1e3
+  } = {}) {
+    let total = 0;
+    let pruned = 0;
+    let cursor;
+    let batch = await this.pendingBlocksArchivist.next({
+      limit: batchSize,
+      cursor,
+      order: "desc"
+    });
+    this.logger?.info(`Starting prunePendingBlocks with batchSize=${batchSize}, maxPrune=${maxPrune}, maxCheck=${maxCheck}`);
+    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
+      const blocksAndBundles = await this.simpleValidationCheck(batch);
+      const blocks = blocksAndBundles.map(([b]) => b);
+      const bundles = blocksAndBundles.map(([_, p]) => p);
+      let valid = blocks.map((b) => !!b);
+      let remainingBlockMap = [];
+      let remainingBlocks = blocks.map((b, i) => {
+        if (b) {
+          remainingBlockMap.push(i);
+          return b;
+        }
+      }).filter(exists$2);
+      assertEx(
+        remainingBlockMap.length === remainingBlocks.length,
+        () => `remainingBlockMap length should match remainingBlocks length [${remainingBlockMap.length}/${remainingBlocks.length}]`
+      );
+      const validationResults = remainingBlocks.map((b) => b);
+      for (const [i, r] of validationResults.entries()) {
+        const validated = isHydratedBlockWithHashMeta(r);
+        if (!validated) {
+          this.logger?.info(`Pruning block ${bundles[remainingBlockMap[i]]._hash} during block validation`);
+          this.logger?.info(`  - validation result: ${JSON.stringify(r, null, 2)}`);
+        }
+        valid[remainingBlockMap[i]] = validated;
+      }
+      const pruneHashes = bundles.map((p, i) => {
+        if (!valid[i]) {
+          return p._hash;
+        }
+      }).filter(exists$2);
+      pruned += pruneHashes.length;
+      total += batch.length;
+      await this.pendingBlocksArchivist.delete(pruneHashes);
+      cursor = batch.at(-1)?._sequence;
+      batch = cursor ? await this.pendingBlocksArchivist.next({
+        limit: batchSize,
+        cursor,
+        order: "desc"
+      }) : [];
+    }
+    this.logger?.info(`prunePendingBlocks completed: pruned=${pruned}, totalChecked=${total}`);
+    return [pruned, total];
+  }
+  prunePendingTransactions(_options) {
+    throw new Error("Method not implemented.");
+  }
   async submitBlocks(blocks) {
     const bundles = await Promise.all(blocks.map(async ([bw, payloads]) => {
       return hydratedBlockToPayloadBundle([
@@ -89137,9 +89232,27 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     const inserted = await this.pendingTransactionsArchivist.insert(bundles);
     return inserted.map((p) => p._hash);
   }
+  async simpleValidationCheck(payloads) {
+    const headNumber = await this.finalizationViewer.headNumber();
+    const chainId = await this.chainContractViewer.chainId();
+    const blockBundles = await Promise.all(payloads.map(async (p) => {
+      return [isPayloadBundle(p) ? await bundledPayloadToHydratedBlock(p) : void 0, p];
+    }));
+    return blockBundles.map(([block, bundle3]) => {
+      const result = [block ? block[0].chain === chainId && block[0].block > headNumber && isSignedHydratedBlockWithHashMeta(block) ? block : void 0 : void 0, bundle3];
+      if (result[0] === void 0) {
+        this.logger?.info(`Pruning block bundle ${bundle3._hash} during simpleValidationCheck`);
+        this.logger?.info(`  - chainId match: ${block ? block[0].chain === chainId : "n/a"}`);
+        this.logger?.info(`  - headNumber check: ${block ? block[0].block > headNumber : "n/a"}`);
+        this.logger?.info(`  - isSignedHydratedBlockWithHashMeta: ${block ? isSignedHydratedBlockWithHashMeta(block) : "n/a"}`);
+        this.logger?.info(`  - block value: ${block ? JSON.stringify(block, null, 2) : "n/a"}`);
+      }
+      return result;
+    });
+  }
 };
 __publicField$4(SimpleMempoolRunner, "defaultMoniker", MempoolRunnerMoniker);
-__publicField$4(SimpleMempoolRunner, "dependencies", [WindowedBlockViewerMoniker]);
+__publicField$4(SimpleMempoolRunner, "dependencies", [FinalizationViewerMoniker, BlockValidationViewerMoniker, ChainContractViewerMoniker]);
 __publicField$4(SimpleMempoolRunner, "monikers", [MempoolRunnerMoniker]);
 SimpleMempoolRunner = __decorateClass$4([
   creatableProvider()
@@ -89192,14 +89305,12 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     });
     this.logger?.info(`Fetched pending transactions: ${bundles.length} bundles`);
     const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta);
-    this.logger?.info(`Filtered pending transactions: ${JSON.stringify(filteredBundles, null, 2)} filteredBundles`);
     const hydratedWithBundle = (await Promise.all(
       filteredBundles.map(async (bundle3) => {
         const tx = await bundledPayloadToHydratedTransaction$1(bundle3);
         return isDefined(tx) ? { bundle: bundle3, tx } : void 0;
       })
     )).filter(exists$2);
-    this.logger?.info(`Converted pending transactions: ${JSON.stringify(hydratedWithBundle.map((x) => x.tx), null, 2)} results`);
     const currentBlock = await this.windowedBlockViewer.currentBlock();
     const evaluated = await Promise.all(
       hydratedWithBundle.map(async ({ bundle: bundle3, tx }) => ({
@@ -96663,6 +96774,12 @@ var JsonRpcMempoolRunnerMethods = class extends AbstractJsonRpcRunner {
 
 // src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
 var JsonRpcMempoolRunner = class extends JsonRpcMempoolRunnerMethods {
+  prunePendingBlocks(_options) {
+    throw new Error("Method not implemented.");
+  }
+  prunePendingTransactions(_options) {
+    throw new Error("Method not implemented.");
+  }
 };
 __publicField$3(JsonRpcMempoolRunner, "defaultMoniker", MempoolRunnerMoniker);
 __publicField$3(JsonRpcMempoolRunner, "dependencies", []);
@@ -96679,12 +96796,16 @@ var JsonRpcXyoRunner = class extends AbstractJsonRpcRunner {
   async broadcastTransaction(transaction) {
     return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [transaction]);
   }
+  async createHandler() {
+    await super.createHandler();
+    this._mempoolRunner = await this.locateAndCreate(MempoolRunnerMoniker);
+  }
   schemas() {
     return XyoRunnerRpcSchemas;
   }
 };
 __publicField$3(JsonRpcXyoRunner, "defaultMoniker", XyoRunnerMoniker);
-__publicField$3(JsonRpcXyoRunner, "dependencies", []);
+__publicField$3(JsonRpcXyoRunner, "dependencies", [MempoolRunnerMoniker]);
 __publicField$3(JsonRpcXyoRunner, "monikers", [XyoRunnerMoniker]);
 JsonRpcXyoRunner = __decorateClass$3([
   creatableProvider()
@@ -202271,13 +202392,13 @@ var AbstractEvmProvider = class extends AbstractCreatableProvider {
     this._contract = this.connectContract(toEthAddress(this.params.address));
   }
 };
-function _ts_decorate3$2(decorators, target, key, desc) {
+function _ts_decorate3$3(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$e(_ts_decorate3$2, "_ts_decorate");
+__name$e(_ts_decorate3$3, "_ts_decorate");
 var EvmChainContractViewer = class _EvmChainContractViewer extends AbstractEvmProvider {
   static {
     __name$e(this, "EvmChainContractViewer");
@@ -202358,7 +202479,7 @@ var EvmChainContractViewer = class _EvmChainContractViewer extends AbstractEvmPr
     return IStakedXyoChain__factory.connect(address, this.params.runner);
   }
 };
-EvmChainContractViewer = _ts_decorate3$2([
+EvmChainContractViewer = _ts_decorate3$3([
   creatableProvider()
 ], EvmChainContractViewer);
 function _ts_decorate4$1(decorators, target, key, desc) {
@@ -203365,13 +203486,13 @@ var BlockValidationDiviner = class extends AbstractDiviner {
 BlockValidationDiviner = _ts_decorate2$2([
   creatableModule()
 ], BlockValidationDiviner);
-function _ts_decorate3$1(decorators, target, key, desc) {
+function _ts_decorate3$2(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$b(_ts_decorate3$1, "_ts_decorate");
+__name$b(_ts_decorate3$2, "_ts_decorate");
 var HeadValidationDivinerConfigSchema = asSchema("network.xyo.diviner.chain.head.validation.config", true);
 var HeadValidationDiviner = class extends AbstractDiviner {
   static {
@@ -203481,7 +203602,7 @@ var HeadValidationDiviner = class extends AbstractDiviner {
     });
   }
 };
-HeadValidationDiviner = _ts_decorate3$1([
+HeadValidationDiviner = _ts_decorate3$2([
   creatableModule()
 ], HeadValidationDiviner);
 async function processPendingBlocks({ blockViewer, context, finalizedArchivist, logger, mempoolViewer }) {
@@ -204752,13 +204873,13 @@ var createBootstrapHead = /* @__PURE__ */ __name$9(async (account, chainId, gene
   chain.push(producerDeclarationBlock);
   return chain;
 }, "createBootstrapHead");
-function _ts_decorate3(decorators, target, key, desc) {
+function _ts_decorate3$1(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$9(_ts_decorate3, "_ts_decorate");
+__name$9(_ts_decorate3$1, "_ts_decorate");
 var BaseNetworkStakeStepRewardService = class _BaseNetworkStakeStepRewardService extends AbstractCreatableProvider {
   static {
     __name$9(this, "BaseNetworkStakeStepRewardService");
@@ -204824,7 +204945,7 @@ var BaseNetworkStakeStepRewardService = class _BaseNetworkStakeStepRewardService
     throw new Error("Method [networkStakeStepRewardsForStepLevel] not implemented.");
   }
 };
-BaseNetworkStakeStepRewardService = _ts_decorate3([
+BaseNetworkStakeStepRewardService = _ts_decorate3$1([
   creatableProvider()
 ], BaseNetworkStakeStepRewardService);
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name$9(async (payload) => {
@@ -205373,19 +205494,20 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
         this.logger?.info(`Built block ${block[0].block} in ${Date.now() - startBuild}ms with ${block[1].length} payloads`);
         this.logger?.info(`Validating block ${block[0].block} with ${block[1].length} payloads`);
         const startValidate = Date.now();
-        const errors = await this.blockValidationViewer.validateBlock(block, {
+        const validatedBlock = await this.blockValidationViewer.validateBlock(block, {
           head: head._hash
         });
         this.logger?.info(`Validated block ${block[0].block} in ${Date.now() - startValidate}ms with ${block[1].length} payloads`);
-        if (errors.length > 0) {
+        if (isSignedHydratedBlockWithHashMeta(validatedBlock)) {
+          await this.mempoolRunner.submitBlocks([
+            validatedBlock
+          ]);
+          return validatedBlock;
+        } else {
+          const errors = validatedBlock;
           this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`);
           const rejectedTransactions = block[1];
           await this.rejectedTransactionsArchivist.insert(rejectedTransactions);
-        } else {
-          await this.mempoolRunner.submitBlocks([
-            block
-          ]);
-          return block;
         }
       } catch (error) {
         this.logger?.error(`Error proposing next valid block: ${error.message}`);
@@ -297280,8 +297402,8 @@ var __name$6 = (target, value) => __defProp$6(target, "name", { value, configura
     __name$6(this, "BalanceActor");
   }
   _updateMutex = new Mutex$1();
-  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");
@@ -297302,7 +297424,7 @@ var __name$6 = (target, value) => __defProp$6(target, "name", { value, configura
     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
       });
     });
@@ -297315,27 +297437,111 @@ function _ts_decorate$2(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name$6(_ts_decorate$2, "_ts_decorate");
+var MempoolActor = class extends Actor {
+  static {
+    __name$6(this, "MempoolActor");
+  }
+  _blockTimerId = null;
+  _blockTimerMutex = new Mutex$1();
+  _transactionTimerId = null;
+  _transactionTimerMutex = new Mutex$1();
+  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: assertEx(params?.mempoolRunner, () => "mempoolRunner is required for MempoolActor"),
+      pendingBlocksArchivist: assertEx(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required for MempoolActor"),
+      pendingTransactionsArchivist: assertEx(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$2([
+  creatable()
+], MempoolActor);
+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$6(_ts_decorate2, "_ts_decorate");
 var ValidatorActor = class extends Actor {
   static {
     __name$6(this, "ValidatorActor");
   }
-  _blockViewer;
   _lastValidatedBlock;
   _lastValidatedBlockHash;
-  _mempoolViewer;
   get blockViewer() {
-    return this._blockViewer;
+    return this.params.blockViewer;
   }
   get finalizedArchivist() {
     return assertEx(this.params.finalizedArchivist, () => "finalizedArchivist not set");
   }
   get mempoolViewer() {
-    return this._mempoolViewer;
+    return this.params.mempoolViewer;
   }
-  async createHandler() {
-    await super.createHandler();
-    this._blockViewer = assertEx(this.params.blockViewer ?? await this.locator?.getInstance(BlockViewerMoniker), () => "Unable to locate a BlockViewer");
-    this._mempoolViewer = assertEx(this.params.mempoolViewer ?? await this.locator?.getInstance(MempoolViewerMoniker), () => "Unable to locate a MempoolViewer");
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      mempoolViewer: assertEx(params?.mempoolViewer, () => "mempoolViewer is required for ValidatorActor"),
+      blockViewer: assertEx(params?.blockViewer, () => "blockViewer is required for ValidatorActor"),
+      finalizedArchivist: assertEx(params?.finalizedArchivist, () => "finalizedArchivist is required for ValidatorActor"),
+      account: assertEx(params?.account, () => "account is required for ValidatorActor")
+    };
   }
   async startHandler() {
     await super.startHandler();
@@ -297372,7 +297578,7 @@ var ValidatorActor = class extends Actor {
     return valid;
   }
 };
-ValidatorActor = _ts_decorate$2([
+ValidatorActor = _ts_decorate2([
   creatable()
 ], ValidatorActor);
 var DEFAULT_STORAGE_ROOT = path.join(process.cwd(), ".store");
@@ -298127,13 +298333,13 @@ async function initRewardsRedemptionApiWallet({ config, logger }) {
   }, mnemonic);
 }
 __name$6(initRewardsRedemptionApiWallet, "initRewardsRedemptionApiWallet");
-function _ts_decorate2(decorators, target, key, desc) {
+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$6(_ts_decorate2, "_ts_decorate");
+__name$6(_ts_decorate3, "_ts_decorate");
 var Orchestrator = class extends AbstractCreatable {
   static {
     __name$6(this, "Orchestrator");
@@ -298186,7 +298392,7 @@ var Orchestrator = class extends AbstractCreatable {
     this.logger?.log("[Orchestrator] Stopped...");
   }
 };
-Orchestrator = _ts_decorate2([
+Orchestrator = _ts_decorate3([
   creatable()
 ], Orchestrator);
 
@@ -298551,6 +298757,10 @@ async function getServer$3(params) {
     node,
     chainId
   });
+  locator.register(SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
+    state: validateHydratedBlockState,
+    protocol: validateHydratedBlock
+  }));
   if (canUseEvmProvider({
     config
   })) {
@@ -298573,6 +298783,9 @@ async function getServer$3(params) {
       address: asAddress(contractAddress, true),
       runner: provider
     }));
+    locator.register(SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {
+      ethProvider: provider
+    }));
   }
   const apiContext = {
     ...initContext,
@@ -298590,14 +298803,29 @@ async function getServer$3(params) {
   assertEx(await accountBalanceViewer.start(), () => "Failed to start AccountBalanceViewer");
   const xyoViewer = await locator.getInstance(XyoViewerMoniker);
   assertEx(await xyoViewer.start(), () => "Failed to start XyoViewer");
+  const mempoolViewer = await locator.getInstance(MempoolViewerMoniker);
+  assertEx(await mempoolViewer.start(), () => "Failed to start MempoolViewer");
+  const mempoolRunner = await locator.getInstance(MempoolRunnerMoniker);
+  assertEx(await mempoolRunner.start(), () => "Failed to start MempoolRunner");
   console.info(`[API] Current block after initialization: #${blk[0].block} (${blk[0]._hash})`);
-  const actor = config.mempool.enabled ? void 0 : await ValidatorActor.create({
+  const validatorActor = config.mempool.enabled ? void 0 : await ValidatorActor.create({
     id: "validator-mempool-server",
     account: wallet,
     context: locator.context,
-    finalizedArchivist: writableChainArchivist
+    finalizedArchivist: writableChainArchivist,
+    mempoolViewer,
+    blockViewer
   });
-  await actor?.start();
+  await validatorActor?.start();
+  const mempoolActor = config.mempool.enabled ? void 0 : await MempoolActor.create({
+    id: "mempool-mempool-server",
+    account: wallet,
+    context: locator.context,
+    mempoolRunner,
+    pendingBlocksArchivist,
+    pendingTransactionsArchivist
+  });
+  await mempoolActor?.start();
   const app = await getApp$3(apiContext);
   const server = app.listen(port, hostname$3, () => logger?.log(`[API] Server listening at http://${hostname$3}:${port}`));
   server.setTimeout(2e4);
@@ -342442,6 +342670,10 @@ var getApp$1 = /* @__PURE__ */ __name$2((context) => {
 var hostname$1 = "::";
 var getProviderFactoryLocator = /* @__PURE__ */ __name$2((context, finalizedArchivist, pendingTransactionsArchivist, pendingBlocksArchivist) => {
   const locator = new ProviderFactoryLocator(context);
+  locator.register(SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
+    state: validateHydratedBlockState,
+    protocol: validateHydratedBlock
+  }));
   locator.register(SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
     pendingTransactionsArchivist,
     pendingBlocksArchivist
@@ -342513,12 +342745,16 @@ var getServer$1 = /* @__PURE__ */ __name$2(async (context) => {
   assertEx(await blockViewer.start(), () => "Failed to start BlockViewer");
   const blk = await blockViewer.currentBlock();
   assertEx(blk, () => "No blocks found after initialization");
+  const mempoolViewer = await locator.getInstance(MempoolViewerMoniker);
+  assertEx(await mempoolViewer.start(), () => "Failed to start MempoolViewer");
   console.info(`[Mempool] Current block after initialization: #${blk[0].block} (${blk[0]._hash})`);
   const actor = await ValidatorActor.create({
     id: "validator-mempool-server",
     account: wallet,
     context: locator.context,
-    finalizedArchivist: writableChainArchivist
+    finalizedArchivist: writableChainArchivist,
+    blockViewer,
+    mempoolViewer
   });
   await actor.start();
   const app = getApp$1(mempoolContext);
@@ -350214,7 +350450,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined("1.19.1") ? "1.19.1" : "unknown";
+var version = isDefined("1.19.3") ? "1.19.3" : "unknown";
 var getContextFromConfig = /* @__PURE__ */ __name(async (configuration2) => {
   const logger = initLogger(configuration2);
   const orchestrator = await Orchestrator.create({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/xl1-cli",
-  "version": "1.19.2",
+  "version": "1.19.4",
   "description": "XYO Layer One CLI",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -75,15 +75,15 @@
     "@xyo-network/payload-model": "~5.3.2",
     "@xyo-network/wallet": "~5.3.2",
     "@xyo-network/wallet-model": "~5.3.2",
-    "@xyo-network/xl1-cli-lib": "~1.19.2",
-    "@xyo-network/xl1-sdk": "~1.20.9",
+    "@xyo-network/xl1-cli-lib": "~1.19.4",
+    "@xyo-network/xl1-sdk": "~1.21.9",
     "async-mutex": "~0.5.0",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.2",
     "ethers": "^6.16.0",
     "nodemon": "~3.1.11",
     "rimraf": "~6.1.2",
-    "rollup": "~4.57.0",
+    "rollup": "~4.57.1",
     "typescript": "~5.9.3",
     "vitest": "~4.0.18",
     "vitest-mock-extended": "~3.1.0",