@xyo-network/xl1-cli 1.19.3 → 1.19.5

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()
@@ -201861,6 +201982,44 @@ async function createChain(signer, stakingTokenAddress, initialBlockProducer, re
   ];
 }
 __name$e(createChain, "createChain");
+var EthHashRegEx = HexRegExMinMaxMixedCaseWithPrefix(32, 32);
+var EthHashZod = string$2().regex(EthHashRegEx, {
+  message: "Invalid address format"
+});
+var EvmStakeAddedEventNameZod = literal$2("StakeAdded");
+var EvmStakeRemovedEventNameZod = literal$2("StakeRemoved");
+var EvmStakeWithdrawnEventNameZod = literal$2("StakeWithdrawn");
+var EvmStakeEventNameZod = union$1([
+  EvmStakeAddedEventNameZod,
+  EvmStakeRemovedEventNameZod,
+  EvmStakeWithdrawnEventNameZod
+]);
+var EvmStakeEventArgsZod = tuple([
+  EthAddressZod,
+  EthAddressZod,
+  bigint$1(),
+  bigint$1()
+]);
+var EvmStakeEventZod = object$4({
+  address: EthAddressZod,
+  args: EvmStakeEventArgsZod,
+  blockHash: EthHashZod,
+  blockNumber: number$3(),
+  eventName: EvmStakeEventNameZod,
+  transactionHash: EthHashZod,
+  transactionIndex: number$3()
+});
+EvmStakeEventZod.extend({
+  eventName: EvmStakeAddedEventNameZod
+});
+EvmStakeEventZod.extend({
+  eventName: EvmStakeRemovedEventNameZod
+});
+EvmStakeEventZod.extend({
+  eventName: EvmStakeWithdrawnEventNameZod
+});
+
+// src/drivers/EvmStakeEventsViewer.ts
 function _ts_decorate$5(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);
@@ -201868,6 +202027,170 @@ function _ts_decorate$5(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name$e(_ts_decorate$5, "_ts_decorate");
+var EvmStakeEventsViewer = class _EvmStakeEventsViewer extends AbstractCreatableProvider {
+  static {
+    __name$e(this, "EvmStakeEventsViewer");
+  }
+  static defaultMoniker = StakeEventsViewerMoniker;
+  static dependencies = [];
+  static monikers = [
+    StakeEventsViewerMoniker
+  ];
+  moniker = _EvmStakeEventsViewer.defaultMoniker;
+  eventCache = /* @__PURE__ */ new Map();
+  get contract() {
+    return assertEx(this.params.contract, () => new Error("Contract not defined"));
+  }
+  get deploymentBlock() {
+    return this.params.deploymentBlock ?? 0;
+  }
+  async positionCount(range) {
+    const events = await this.stakeEvents(range);
+    const positionIds = events.map((e) => e.args.id);
+    return Math.max(-1, ...positionIds) + 1;
+  }
+  stakeEvents(range = [
+    0,
+    "latest"
+  ], filter) {
+    const allEvents = [
+      ...this.eventCache.values()
+    ];
+    const result = allEvents.filter((e) => {
+      if (range[1] !== "latest" && e.time > range[1]) {
+        return false;
+      }
+      if (e.time < range[0]) {
+        return false;
+      }
+      if (isDefined(filter?.name) && e.name !== filter.name) {
+        return false;
+      }
+      if (isDefined(filter?.args?.id) && e.args.id !== filter.args.id) {
+        return false;
+      }
+      if (isDefined(filter?.args?.staked) && e.args.staked !== filter.args.staked) {
+        return false;
+      }
+      if (isDefined(filter?.args?.staker) && e.args.staker !== filter.args.staker) {
+        return false;
+      }
+      return true;
+    });
+    return result;
+  }
+  onEventHandler(staked, staker, id, amount, event, throwOnInvalid = false) {
+    const validatedEventResult = EvmStakeEventZod.safeParse(event);
+    if (validatedEventResult.error) {
+      this.logger?.warn(`Received invalid stake event [${event.eventName}/${event.blockNumber}], ignoring...`);
+      this.logger?.warn(` - ${validatedEventResult.error.message}`);
+      if (throwOnInvalid) {
+        throw new Error(`Invalid stake event: ${validatedEventResult.error.message}`);
+      }
+      return;
+    }
+    const validatedEvent = validatedEventResult.data;
+    const { eventName, blockNumber } = validatedEvent;
+    this.logger?.log(`Processing ${eventName} event for stake ID ${id} at block ${blockNumber}`);
+    const cacheKey = `${Number(id)}|${eventName}|${staker}`;
+    const existingStakeEvent = this.eventCache.get(cacheKey);
+    const stakeEvent = {
+      name: eventName,
+      args: {
+        id: Number(id),
+        staked: toAddress(staked),
+        staker: toAddress(staker),
+        amount: asAttoXL1(amount)
+      },
+      time: blockNumber
+    };
+    if (isDefined(existingStakeEvent)) {
+      this.logger?.warn(`Received ${eventName} event for stake ID ${id} that is already cached, updating cache...`);
+      this.logger?.warn("1");
+      this.logger?.warn("Previous event", existingStakeEvent);
+      this.logger?.warn("2");
+      this.logger?.warn("New event", stakeEvent);
+      this.logger?.warn("3");
+    }
+    this.eventCache.set(cacheKey, stakeEvent);
+    return stakeEvent;
+  }
+  async startHandler() {
+    try {
+      const currentEthBlock = assertEx(await this.contract.runner?.provider?.getBlockNumber(), () => new Error("Failed to egt currentEthBlock"));
+      await this.contract.on(this.contract.getEvent("StakeAdded"), (staked, staker, id, amount, event) => {
+        this.onEventHandler(staked, staker, id, amount, event);
+      });
+      await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
+        this.onEventHandler(staked, staker, id, amount, event);
+      });
+      await this.contract.on(this.contract.getEvent("StakeWithdrawn"), (staked, staker, id, amount, event) => {
+        this.onEventHandler(staked, staker, id, amount, event);
+      });
+      await this.loadHistoricalEvents(currentEthBlock);
+    } catch (error) {
+      this.logger?.error("EthereumChainStakeEvents failed to start:", error);
+      throw error;
+    }
+  }
+  async loadHistoricalEvents(currentEthBlock) {
+    const allStakeEvents = (await Promise.all([
+      this.stakeEventsNative([
+        this.deploymentBlock,
+        currentEthBlock
+      ], {
+        name: "StakeAdded"
+      }),
+      this.stakeEventsNative([
+        this.deploymentBlock,
+        currentEthBlock
+      ], {
+        name: "StakeRemoved"
+      }),
+      this.stakeEventsNative([
+        this.deploymentBlock,
+        currentEthBlock
+      ], {
+        name: "StakeWithdrawn"
+      })
+    ])).flat().toSorted((a, b) => a.time - b.time);
+    console.warn(`Caching ${allStakeEvents.length} stake events from chain starting at block ${this.deploymentBlock}`);
+    for (const event of allStakeEvents) {
+      this.eventCache.set(`${Number(event.args.id)}|${event.name}|${event.args.staker}`, event);
+    }
+  }
+  async stakeEventsNative(range = [
+    0,
+    "latest"
+  ], filter) {
+    const name = filter?.name;
+    if (isDefined(name)) {
+      const stakedFilter = filter?.args?.staked;
+      const stakerFilter = filter?.args?.staker;
+      const stakedFilterEth = isDefined(stakedFilter) ? toEthAddress(stakedFilter) : void 0;
+      const stakerFilterEth = isDefined(stakerFilter) ? toEthAddress(stakerFilter) : void 0;
+      let ethEvents = [];
+      const ethFilter = this.contract.filters[name](stakedFilterEth, stakerFilterEth);
+      ethEvents = await this.contract.queryFilter(ethFilter, range[0], range[1]);
+      return ethEvents.map((e) => {
+        assertEx(e.eventName === name, () => `Event name mismatch expected '${name}' but got '${e.eventName}'`);
+        return this.onEventHandler(e.args.staked, e.args.by, e.args.id, e.args.amount, e, true);
+      }).filter(exists$2);
+    } else {
+      throw new Error("Only filtered stake events (by name) are supported");
+    }
+  }
+};
+EvmStakeEventsViewer = _ts_decorate$5([
+  creatableProvider()
+], EvmStakeEventsViewer);
+function _ts_decorate2$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_decorate2$3, "_ts_decorate");
 var ethStakeToStake = /* @__PURE__ */ __name$e((ethStake) => {
   const stake = {
     id: Number(ethStake.id),
@@ -201880,16 +202203,16 @@ var ethStakeToStake = /* @__PURE__ */ __name$e((ethStake) => {
   };
   return stake;
 }, "ethStakeToStake");
-var EthereumChainStakeViewer = class _EthereumChainStakeViewer extends AbstractCreatableProvider {
+var EvmStakeViewer = class _EvmStakeViewer extends AbstractCreatableProvider {
   static {
-    __name$e(this, "EthereumChainStakeViewer");
+    __name$e(this, "EvmStakeViewer");
   }
   static defaultMoniker = StakeViewerMoniker;
   static dependencies = [];
   static monikers = [
     StakeViewerMoniker
   ];
-  moniker = _EthereumChainStakeViewer.defaultMoniker;
+  moniker = _EvmStakeViewer.defaultMoniker;
   _callMutex = new Mutex$1();
   _deploymentBlock = 0;
   _stakeCache = /* @__PURE__ */ new Map();
@@ -202090,174 +202413,9 @@ var EthereumChainStakeViewer = class _EthereumChainStakeViewer extends AbstractC
     }
   }
 };
-EthereumChainStakeViewer = _ts_decorate$5([
-  creatableProvider()
-], EthereumChainStakeViewer);
-function _ts_decorate2$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_decorate2$3, "_ts_decorate");
-var isStakeLogEventName = /* @__PURE__ */ __name$e((name) => {
-  return isString$1(name) && [
-    "StakeAdded",
-    "StakeRemoved",
-    "StakeWithdrawn"
-  ].includes(name);
-}, "isStakeLogEventName");
-var EthereumChainStakeEventsViewer = class _EthereumChainStakeEventsViewer extends AbstractCreatableProvider {
-  static {
-    __name$e(this, "EthereumChainStakeEventsViewer");
-  }
-  static defaultMoniker = StakeEventsViewerMoniker;
-  static dependencies = [];
-  static monikers = [
-    StakeEventsViewerMoniker
-  ];
-  moniker = _EthereumChainStakeEventsViewer.defaultMoniker;
-  eventCache = /* @__PURE__ */ new Map();
-  get contract() {
-    return assertEx(this.params.contract, () => new Error("Contract not defined"));
-  }
-  get deploymentBlock() {
-    return this.params.deploymentBlock ?? 0;
-  }
-  async positionCount(range) {
-    const events = await this.stakeEvents(range);
-    const positionIds = events.map((e) => e.args.id);
-    return Math.max(-1, ...positionIds) + 1;
-  }
-  stakeEvents(range = [
-    0,
-    "latest"
-  ], filter) {
-    const allEvents = [
-      ...this.eventCache.values()
-    ];
-    const result = allEvents.filter((e) => {
-      if (range[1] !== "latest" && e.time > range[1]) {
-        return false;
-      }
-      if (e.time < range[0]) {
-        return false;
-      }
-      if (isDefined(filter?.name) && e.name !== filter.name) {
-        return false;
-      }
-      if (isDefined(filter?.args?.id) && e.args.id !== filter.args.id) {
-        return false;
-      }
-      if (isDefined(filter?.args?.staked) && e.args.staked !== filter.args.staked) {
-        return false;
-      }
-      if (isDefined(filter?.args?.staker) && e.args.staker !== filter.args.staker) {
-        return false;
-      }
-      return true;
-    });
-    return result;
-  }
-  onEventHandler(staked, staker, id, amount, { eventName, blockNumber }) {
-    if (blockNumber === void 0) {
-      this.logger?.warn(`Received ${eventName} event with ${blockNumber} blockNumber, ignoring...`);
-      return;
-    }
-    if (!isStakeLogEventName(eventName)) {
-      this.logger?.warn(`Received event with unsupported name '${eventName}'`);
-      return;
-    }
-    this.logger?.log(`Processing ${eventName} event for stake ID ${id} at block ${blockNumber}`);
-    const cacheKey = `${Number(id)}|${eventName}|${staker}`;
-    const existingStakeEvent = this.eventCache.get(cacheKey);
-    const stakeEvent = {
-      name: eventName,
-      args: {
-        id: Number(id),
-        staked: toAddress(staked),
-        staker: toAddress(staker),
-        amount: asAttoXL1(amount)
-      },
-      time: blockNumber
-    };
-    if (isDefined(existingStakeEvent)) {
-      this.logger?.warn(`Received ${eventName} event for stake ID ${id} that is already cached, updating cache...`);
-      this.logger?.warn("1");
-      this.logger?.warn("Previous event", existingStakeEvent);
-      this.logger?.warn("2");
-      this.logger?.warn("New event", stakeEvent);
-      this.logger?.warn("3");
-    }
-    this.eventCache.set(cacheKey, stakeEvent);
-    return stakeEvent;
-  }
-  async startHandler() {
-    try {
-      const currentEthBlock = assertEx(await this.contract.runner?.provider?.getBlockNumber(), () => new Error("Failed to egt currentEthBlock"));
-      await this.contract.on(this.contract.getEvent("StakeAdded"), (staked, staker, id, amount, event) => {
-        this.onEventHandler(staked, staker, id, amount, event);
-      });
-      await this.contract.on(this.contract.getEvent("StakeRemoved"), (staked, staker, id, amount, event) => {
-        this.onEventHandler(staked, staker, id, amount, event);
-      });
-      await this.contract.on(this.contract.getEvent("StakeWithdrawn"), (staked, staker, id, amount, event) => {
-        this.onEventHandler(staked, staker, id, amount, event);
-      });
-      const allStakeEvents = (await Promise.all([
-        this.stakeEventsNative([
-          this.deploymentBlock,
-          currentEthBlock
-        ], {
-          name: "StakeAdded"
-        }),
-        this.stakeEventsNative([
-          this.deploymentBlock,
-          currentEthBlock
-        ], {
-          name: "StakeRemoved"
-        }),
-        this.stakeEventsNative([
-          this.deploymentBlock,
-          currentEthBlock
-        ], {
-          name: "StakeWithdrawn"
-        })
-      ])).flat().toSorted((a, b) => a.time - b.time);
-      console.warn(`Caching ${allStakeEvents.length} stake events from chain starting at block ${this.deploymentBlock}`);
-      for (const event of allStakeEvents) {
-        this.eventCache.set(`${Number(event.args.id)}|${event.name}|${event.args.staker}`, event);
-      }
-    } catch (error) {
-      this.logger?.error("EthereumChainStakeEvents failed to start:", error);
-      throw error;
-    }
-  }
-  async stakeEventsNative(range = [
-    0,
-    "latest"
-  ], filter) {
-    const name = filter?.name;
-    if (isDefined(name)) {
-      const stakedFilter = filter?.args?.staked;
-      const stakerFilter = filter?.args?.staker;
-      const stakedFilterEth = isDefined(stakedFilter) ? toEthAddress(stakedFilter) : void 0;
-      const stakerFilterEth = isDefined(stakerFilter) ? toEthAddress(stakerFilter) : void 0;
-      let ethEvents = [];
-      const ethFilter = this.contract.filters[name](stakedFilterEth, stakerFilterEth);
-      ethEvents = await this.contract.queryFilter(ethFilter, range[0], range[1]);
-      return ethEvents.map((e) => {
-        assertEx(e.eventName === name, () => `Event name mismatch expected '${name}' but got '${e.eventName}'`);
-        return this.onEventHandler(e.args.staked, e.args.by, e.args.id, e.args.amount, e);
-      }).filter(exists$2);
-    } else {
-      throw new Error("Only filtered stake events (by name) are supported");
-    }
-  }
-};
-EthereumChainStakeEventsViewer = _ts_decorate2$3([
+EvmStakeViewer = _ts_decorate2$3([
   creatableProvider()
-], EthereumChainStakeEventsViewer);
+], EvmStakeViewer);
 var AbstractEvmProvider = class extends AbstractCreatableProvider {
   static {
     __name$e(this, "AbstractEvmProvider");
@@ -202271,13 +202429,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 +202516,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 +203523,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 +203639,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 +204910,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 +204982,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 +205531,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 +297439,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 +297461,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 +297474,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 +297615,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");
@@ -297693,19 +297936,19 @@ async function initEvmChainStakeViewer(context, config, logger) {
   });
   const contractAddress = assertEx(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
   });
-  assertEx(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
-  const stakeChainViewer = await EthereumChainStakeViewer.create({
+  assertEx(await stakeEventsViewer.start(), () => "Failed to start EvmStakeEvents reader");
+  const stakeChainViewer = await EvmStakeViewer.create({
     contract,
     stakeEventsViewer,
     logger,
     context
   });
-  assertEx(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
+  assertEx(await stakeChainViewer.start(), () => "Failed to start EvmStake viewer");
   return stakeChainViewer;
 }
 __name$6(initEvmChainStakeViewer, "initEvmChainStakeViewer");
@@ -298127,13 +298370,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 +298429,7 @@ var Orchestrator = class extends AbstractCreatable {
     this.logger?.log("[Orchestrator] Stopped...");
   }
 };
-Orchestrator = _ts_decorate2([
+Orchestrator = _ts_decorate3([
   creatable()
 ], Orchestrator);
 
@@ -298551,6 +298794,10 @@ async function getServer$3(params) {
     node,
     chainId
   });
+  locator.register(SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
+    state: validateHydratedBlockState,
+    protocol: validateHydratedBlock
+  }));
   if (canUseEvmProvider({
     config
   })) {
@@ -298560,12 +298807,12 @@ async function getServer$3(params) {
     });
     const contractAddress = assertEx(config.chain.id, () => "Missing config.chain.chainId");
     const contract = IStakedXyoChain__factory.connect(toEthAddress(contractAddress), provider);
-    locator.register(EthereumChainStakeEventsViewer.factory(EthereumChainStakeEventsViewer.dependencies, {
+    locator.register(EvmStakeEventsViewer.factory(EvmStakeEventsViewer.dependencies, {
       contract
     }));
-    const stakeEventsViewer = await locator.getInstance(EthereumChainStakeEventsViewer.defaultMoniker);
-    assertEx(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEventsViewer");
-    locator.register(EthereumChainStakeViewer.factory(EthereumChainStakeViewer.dependencies, {
+    const stakeEventsViewer = await locator.getInstance(EvmStakeEventsViewer.defaultMoniker);
+    assertEx(await stakeEventsViewer.start(), () => "Failed to start EvmStakeEventsViewer");
+    locator.register(EvmStakeViewer.factory(EvmStakeViewer.dependencies, {
       contract,
       stakeEventsViewer
     }));
@@ -298573,6 +298820,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 +298840,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 +342707,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 +342782,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 +350487,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined("1.19.2") ? "1.19.2" : "unknown";
+var version = isDefined("1.19.4") ? "1.19.4" : "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.3",
+  "version": "1.19.5",
   "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.3",
-    "@xyo-network/xl1-sdk": "~1.20.9",
+    "@xyo-network/xl1-cli-lib": "~1.19.5",
+    "@xyo-network/xl1-sdk": "~1.21.10",
     "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",