@xyo-network/chain-services 1.19.14 → 1.19.16

package/dist/neutral/index.mjs

@@ -236,321 +236,24 @@ BaseNetworkStakeStepRewardService = _ts_decorate3([
   creatableProvider2()
 ], BaseNetworkStakeStepRewardService);
 
-// src/PendingTransactions/BasePendingTransactions.ts
-import { ValueType } from "@opentelemetry/api";
-import { assertEx as assertEx3, exists, filterAs, filterAsync, forget, isDefined, isUndefined } from "@xylabs/sdk-js";
-import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { AbstractCreatableProvider as AbstractCreatableProvider4, asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, creatableProvider as creatableProvider3, findMostRecentBlock, isTransactionBoundWitnessWithStorageMeta, MempoolViewerMoniker, TransactionJsonSchemaValidator, validateTransaction } from "@xyo-network/xl1-sdk";
-import { Mutex } from "async-mutex";
-
-// src/PendingTransactions/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { asSignedTransactionBoundWitnessWithHashMeta } from "@xyo-network/xl1-sdk";
-var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withHashMeta = await PayloadBuilder.addHashMeta(payload.payloads);
-  const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
-  if (tx) {
-    return [
-      tx,
-      withHashMeta.filter((p) => p._hash !== payload.root)
-    ];
-  }
-}, "bundledPayloadToHydratedTransaction");
-
-// src/PendingTransactions/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { PayloadBundleSchema } from "@xyo-network/payload-model";
-import { flattenHydratedTransaction } from "@xyo-network/xl1-sdk";
-var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) => {
-  const root = transaction[0]._hash;
-  return bundle(root, transaction);
-}, "hydratedTransactionToPayloadBundle");
-var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder2.omitStorageMeta(p));
-  return new PayloadBuilder2({
-    schema: PayloadBundleSchema
-  }).fields({
-    payloads,
-    root
-  }).build();
-}, "bundle");
-
-// src/PendingTransactions/BasePendingTransactions.ts
-function _ts_decorate4(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate4, "_ts_decorate");
-var BasePendingTransactionsService = class _BasePendingTransactionsService extends AbstractCreatableProvider4 {
-  static {
-    __name(this, "BasePendingTransactionsService");
-  }
-  static defaultMoniker = MempoolViewerMoniker;
-  static dependencies = [];
-  static monikers = [
-    MempoolViewerMoniker
-  ];
-  static MutexPriority = {
-    /**
-    * Priority for inserting new transactions
-    */
-    InsertNewTransactions: 5,
-    /**
-    * Priority for reading pending transactions
-    */
-    ReadTransactions: 3,
-    /**
-    * Priority for removing finalized/expired/rejected transactions
-    */
-    PurgeTransactions: 1
-  };
-  moniker = _BasePendingTransactionsService.defaultMoniker;
-  /**
-  * A mutex to ensure that the counting the number of pending transactions is
-  * not called concurrently
-  */
-  _countPendingTransactionsMutex = new Mutex();
-  /**
-  * A local Archivist optimized for fast retrieval that stores only validated
-  * pending transactions
-  */
-  _curatedPendingBundledTransactionsArchivist;
-  /**
-  * The last count of total pending transactions
-  */
-  _pendingTransactionsCount = 0;
-  /**
-  * A set of transaction hashes that are pending removal from the
-  * curated pending transactions archivist. This is used to track
-  * which transactions need to be removed from the archivist.
-  */
-  _removablePendingTransactionHashes = /* @__PURE__ */ new Set();
-  /**
-  * A mutex to ensure that the curated pending transactions archivist is
-  * updated in a thread-safe manner
-  */
-  _updateCuratedPendingTransactionsArchivistMutex = new Mutex();
-  get additionalPendingTransactionValidators() {
-    return this.params.additionalPendingTransactionValidators ?? [];
-  }
-  get chainArchivist() {
-    return assertEx3(this.params.chainArchivist, () => "No completed blocks with data archivist");
-  }
-  get pendingBundledTransactionsArchivist() {
-    return assertEx3(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
-  }
-  get pendingBundledTransactionsLocalArchivist() {
-    return assertEx3(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
-  }
-  get pendingTransactionsCount() {
-    forget(this.countPendingTransactions());
-    return this._pendingTransactionsCount;
-  }
-  get rejectedTransactionsArchivist() {
-    return assertEx3(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
-  }
-  async createHandler() {
-    await super.createHandler();
-    this._curatedPendingBundledTransactionsArchivist = await MemoryArchivist.create({
-      account: "random"
-    });
-    this.pendingBundledTransactionsArchivist.on("inserted", ({ payloads }) => {
-      forget(this.insertNewTransactions(payloads));
-    });
-    this.chainArchivist.on("inserted", ({ payloads }) => {
-      this.markAnyIncludedTransactionsForRemoval(payloads);
-      forget(this.cleanupWorker());
-    });
-    this.rejectedTransactionsArchivist.on("inserted", ({ payloads }) => {
-      this.markAnyIncludedTransactionsForRemoval(payloads);
-      forget(this.cleanupWorker());
-    });
-    const pendingTransactionsCounter = this.meter?.createObservableUpDownCounter("xyo_pending_transactions_counter", {
-      description: "The current number of pending transactions",
-      valueType: ValueType.INT,
-      unit: "1"
-    });
-    pendingTransactionsCounter?.addCallback((observer) => {
-      observer.observe(this.pendingTransactionsCount);
-    });
-  }
-  pendingBlocks(_options) {
-    throw new Error("Method [pendingBlocks] not implemented.");
-  }
-  async pendingTransactions({ limit = 100 } = {}) {
-    return await this.spanAsync("getPendingTransactions", async () => {
-      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        let lastHead = filterAs(await this.chainArchivist.next({
-          limit: 100
-        }), (x) => asBlockBoundWitnessWithHashMeta(x)).at(-1);
-        if (isUndefined(lastHead)) return [];
-        await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
-        const foundPendingTransactions = [];
-        let cursor;
-        while (foundPendingTransactions.length < limit) {
-          const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
-            limit: 100,
-            order: "asc",
-            cursor
-          });
-          if (pendingBundledTransactions.length === 0) break;
-          cursor = pendingBundledTransactions.at(-1)?._sequence;
-          const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-          const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists);
-          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber(lastHead.block + 1, true)));
-          const txValidationResults = await Promise.all(activeTransactions.map(async (tx) => [
-            tx,
-            await validateTransaction({
-              ...this.context,
-              chainId: this.params.chainId
-            }, tx, this.additionalPendingTransactionValidators)
-          ]));
-          const validTransactions = txValidationResults.filter(([, errors]) => errors.length === 0).map(([tx]) => tx);
-          const invalidTransactions = txValidationResults.filter(([, errors]) => errors.length > 0).map(([tx]) => tx);
-          if (invalidTransactions.length > 0) {
-            this.logger?.warn(`getPendingTransactions: Found ${invalidTransactions.length} invalid pending transactions`);
-            for (const tx of invalidTransactions) {
-              this.logger?.warn(tx[0]._hash);
-            }
-          }
-          foundPendingTransactions.push(...validTransactions);
-        }
-        if (foundPendingTransactions.length > 0) {
-          this.logger?.log(`getPendingTransactions: Found ${foundPendingTransactions.length} pending transactions`);
-          for (const tx of foundPendingTransactions) {
-            this.logger?.log(tx[0]._hash);
-          }
-        }
-        return foundPendingTransactions;
-      }, _BasePendingTransactionsService.MutexPriority.ReadTransactions);
-    }, this.context);
-  }
-  async cleanupWorker() {
-    return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-      const lastHead = await findMostRecentBlock(this.chainArchivist);
-      if (isDefined(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
-    }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
-  }
-  async countPendingTransactions() {
-    if (this._countPendingTransactionsMutex.isLocked()) return;
-    await this._countPendingTransactionsMutex.runExclusive(async () => {
-      const payloads = await this._curatedPendingBundledTransactionsArchivist?.all() ?? [];
-      this._pendingTransactionsCount = payloads.length;
-    });
-  }
-  async filterAlreadyFinalizedTransactions(incomingTransactions) {
-    const incomingTransactionHashes = incomingTransactions.map((payload) => payload.root);
-    const finalizedTransactions = await this.chainArchivist.get(incomingTransactionHashes);
-    const finalizedTransactionHashes = new Set(finalizedTransactions.map((item) => item._hash));
-    const nonFinalizedTransactions = incomingTransactions.filter((item) => !finalizedTransactionHashes.has(item._hash));
-    return nonFinalizedTransactions;
-  }
-  async insertNewTransactions(payloads) {
-    if (payloads.length === 0) return;
-    return await this.spanAsync("InsertNewTransactions", async () => {
-      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
-        const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map(async (tx) => {
-          return await bundledPayloadToHydratedTransaction(tx);
-        }))).filter(exists);
-        const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
-          const errors = await validateTransaction({
-            ...this.context,
-            chainId: this.params.chainId
-          }, tx, [
-            TransactionJsonSchemaValidator
-          ]);
-          if (errors.length > 0) {
-            this.logger?.warn("validateTransaction", errors);
-          }
-          return errors.length > 0 ? false : true;
-        });
-        if (validTransactions.length > 0) {
-          const bundledTransactions = validTransactions.map((tx) => hydratedTransactionToPayloadBundle(tx));
-          await this.pendingBundledTransactionsLocalArchivist.insert(bundledTransactions);
-        }
-      }, _BasePendingTransactionsService.MutexPriority.InsertNewTransactions);
-    }, this.context);
-  }
-  /**
-  * Marks any included transactions in the provided payloads for removal preventing them
-  * from being included in the curated pending transactions archivist and from being offered
-  * during the next retrieval of pending transactions.
-  * @param payloads An array of payloads that may contain transactions.
-  */
-  markAnyIncludedTransactionsForRemoval(payloads) {
-    const hashes = payloads.filter(isTransactionBoundWitnessWithStorageMeta).map((p) => p._hash);
-    for (const hash of hashes) {
-      this._removablePendingTransactionHashes.add(hash);
-    }
-  }
-  async pruneCuratedPendingTransactionsArchivist(head) {
-    return await this.spanAsync("pruneCuratedPendingTransactionsArchivist", async () => {
-      const foundPendingTransactionsToDeleteHashes = [];
-      let cursor;
-      let [lastHead] = filterAs(await this.chainArchivist.get([
-        head
-      ]), (x) => asBlockBoundWitnessWithHashMeta(x));
-      while (isDefined(lastHead)) {
-        const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
-          limit: 100,
-          order: "asc",
-          cursor
-        });
-        if (pendingBundledTransactions.length === 0) {
-          break;
-        }
-        cursor = pendingBundledTransactions.at(-1)?._sequence;
-        const deletedTransactionBundles = pendingBundledTransactions.filter((tx) => this._removablePendingTransactionHashes.has(tx.root));
-        foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists));
-        const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-        const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists);
-        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber(lastHead.block + 1, true)));
-        const expiredBundleHashes = expiredTransactions.map((expiredHydratedTx) => (
-          // Find the corresponding payload bundle hash for the expired transaction
-          pendingBundledTransactions.find((bundledTx) => bundledTx.root === expiredHydratedTx[0]._hash)?._hash
-        )).filter(exists);
-        foundPendingTransactionsToDeleteHashes.push(...expiredBundleHashes);
-      }
-      const deletedHashes = await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes);
-      for (const payload of deletedHashes) {
-        this._removablePendingTransactionHashes.delete(payload._hash);
-      }
-      if (deletedHashes.length > 0) {
-        this.logger?.log(`foundPendingTransactionsToDeleteHashes: Found ${deletedHashes.length} deletable transactions`);
-        for (const payload of deletedHashes) {
-          this.logger?.log(payload._hash);
-        }
-      }
-    }, this.context);
-  }
-};
-BasePendingTransactionsService = _ts_decorate4([
-  creatableProvider3()
-], BasePendingTransactionsService);
-var isTransactionExpired = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.exp < block, "isTransactionExpired");
-var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block, "isTransactionActive");
-
 // src/simple/block/runner/SimpleBlockRunner.ts
-import { assertEx as assertEx5, exists as exists2, hexToBigInt, isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { MemoryArchivist as MemoryArchivist2 } from "@xyo-network/archivist-memory";
+import { assertEx as assertEx4, exists, hexToBigInt, isDefined } from "@xylabs/sdk-js";
+import { MemoryArchivist } from "@xyo-network/archivist-memory";
 import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
 import { buildNextBlock as buildNextBlock2 } from "@xyo-network/chain-protocol";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { AbstractCreatableProvider as AbstractCreatableProvider5, AccountBalanceViewerMoniker, asBlockBoundWitness, AttoXL1, BlockNumberSchema, BlockRewardViewerMoniker as BlockRewardViewerMoniker2, BlockRunnerMoniker, BlockValidationViewerMoniker, creatableProvider as creatableProvider4, createDeclarationIntent as createDeclarationIntent2, defaultRewardRatio, isSignedHydratedBlockWithHashMeta, MempoolRunnerMoniker, MempoolViewerMoniker as MempoolViewerMoniker2, TimeSyncViewerMoniker, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-sdk";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { AbstractCreatableProvider as AbstractCreatableProvider4, AccountBalanceViewerMoniker, asBlockBoundWitness, AttoXL1, BlockNumberSchema, BlockRewardViewerMoniker as BlockRewardViewerMoniker2, BlockRunnerMoniker, BlockValidationViewerMoniker, creatableProvider as creatableProvider3, createDeclarationIntent as createDeclarationIntent2, defaultRewardRatio, isSignedHydratedBlockWithHashMeta, MempoolRunnerMoniker, MempoolViewerMoniker, TimeSyncViewerMoniker, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-sdk";
 
 // src/simple/block/runner/generateTransactionFeeTransfers.ts
 import { hexFromBigInt } from "@xylabs/sdk-js";
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { PayloadBuilder } from "@xyo-network/sdk-js";
 import { HydratedTransactionWrapper, transactionRequiredGas, TransferSchema, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
 async function generateTransactionFeeTransfers(address, transactions) {
   const txs = await Promise.all(transactions.map(async (tx) => {
     return HydratedTransactionWrapper.parse([
-      await PayloadBuilder3.addStorageMeta(tx[0]),
-      await PayloadBuilder3.addStorageMeta(tx[1])
+      await PayloadBuilder.addStorageMeta(tx[0]),
+      await PayloadBuilder.addStorageMeta(tx[1])
     ]);
   }));
   const txBaseFeeCosts = {};
@@ -576,7 +279,7 @@ async function generateTransactionFeeTransfers(address, transactions) {
     return payload;
   });
   for (const [from, amount] of Object.entries(txGasCosts)) {
-    const fromPayload = assertEx4(payloads.find((p) => p.from === from), () => "from payload not found");
+    const fromPayload = assertEx3(payloads.find((p) => p.from === from), () => "from payload not found");
     fromPayload.transfers[address] = hexFromBigInt(amount);
   }
   return payloads;
@@ -584,17 +287,17 @@ async function generateTransactionFeeTransfers(address, transactions) {
 __name(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
 
 // src/simple/block/runner/SimpleBlockRunner.ts
-function _ts_decorate5(decorators, target, key, desc) {
+function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate5, "_ts_decorate");
+__name(_ts_decorate4, "_ts_decorate");
 var DEFAULT_BLOCK_SIZE = 10;
 var XYO_PRODUCER_REDECLARATION_DURATION = 1e4;
 var XYO_PRODUCER_REDECLARATION_WINDOW = 500;
-var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvider5 {
+var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvider4 {
   static {
     __name(this, "SimpleBlockRunner");
   }
@@ -604,7 +307,7 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
     BlockRewardViewerMoniker2,
     BlockValidationViewerMoniker,
     MempoolRunnerMoniker,
-    MempoolViewerMoniker2,
+    MempoolViewerMoniker,
     TimeSyncViewerMoniker
   ];
   static monikers = [
@@ -662,9 +365,9 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
   get chainId() {
     return this._chainId;
   }
-  // protected get electionService() {
-  //   return assertEx(this.params.electionService, () => 'electionService is required')
-  // }
+  get heartbeatInterval() {
+    return this.params.heartbeatInterval ?? 36e5;
+  }
   get mempoolRunner() {
     return this._mempoolRunner;
   }
@@ -690,16 +393,16 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
   //   return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
   // }
   async createHandler() {
-    this._rejectedTransactionsArchivist = this.params.rejectedTransactionsArchivist ?? await MemoryArchivist2.create();
-    this._account = assertEx5(this.params.account, () => "Account is required");
+    this._rejectedTransactionsArchivist = this.params.rejectedTransactionsArchivist ?? await MemoryArchivist.create();
+    this._account = assertEx4(this.params.account, () => "Account is required");
     this._address = this.account.address;
     this._accountBalanceViewer = await this.locateAndCreate(AccountBalanceViewerMoniker);
     this._blockRewardViewer = await this.locateAndCreate(BlockRewardViewerMoniker2);
     this._blockValidationViewer = await this.locator.getInstance(BlockValidationViewerMoniker);
     this._chainId = this.context.config.chain.id;
     this._mempoolRunner = await this.locateAndCreate(MempoolRunnerMoniker);
-    this._mempoolViewer = await this.locateAndCreate(MempoolViewerMoniker2);
-    this._rewardAddress = this.params.rewardAddress ?? this.context.config.actors.producer.rewardAddress;
+    this._mempoolViewer = await this.locateAndCreate(MempoolViewerMoniker);
+    this._rewardAddress = this.params.rewardAddress;
     this._timeSyncViewer = await this.locateAndCreate(TimeSyncViewerMoniker);
   }
   async next(head) {
@@ -707,7 +410,7 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
   }
   async produceNextBlock(head, force) {
     const result = await this.proposeNextValidBlock(head);
-    return force ? assertEx5(result, () => "Failed to produce next block") : result;
+    return force ? assertEx4(result, () => "Failed to produce next block") : result;
   }
   async getBlockRewardTransfers(block) {
     if (!this._blockRewardDiviner) {
@@ -721,7 +424,7 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
         }
       });
     }
-    const blockId = new PayloadBuilder4({
+    const blockId = new PayloadBuilder2({
       schema: BlockNumberSchema
     }).fields({
       block
@@ -737,14 +440,14 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
   * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
   */
   getProducerRedeclaration(head) {
-    if (this.params.context.config.actors?.producer?.disableIntentRedeclaration) return;
+    if (this.params.disableIntentRedeclaration) return;
     const currentBlock = head.block;
     return createDeclarationIntent2(this.address, "producer", currentBlock, currentBlock + _SimpleBlockRunner.RedeclarationDuration);
   }
   async proposeNextValidBlock(head, validateBalances = false, force = false) {
     return await this.spanAsync("proposeNextValidBlock", async () => {
       try {
-        const { block: previousBlock } = assertEx5(asBlockBoundWitness(head), () => "Invalid head block");
+        const { block: previousBlock } = assertEx4(asBlockBoundWitness(head), () => "Invalid head block");
         const nextBlock = previousBlock + 1;
         const nextBlockTransactions = await this.mempoolViewer.pendingTransactions({
           limit: _SimpleBlockRunner.DefaultBlockSize
@@ -816,7 +519,7 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
         fundedTransfers.push(transfer);
         return tx;
       }
-    }))).filter(exists2);
+    }))).filter(exists);
     return [
       fundedTransactions,
       fundedTransfers
@@ -832,265 +535,19 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
   */
   heartbeatRequired(head) {
     const epoch = head.$epoch;
-    if (isDefined2(epoch)) {
-      const { heartbeatInterval } = assertEx5(this.params.context.config.actors?.producer);
-      if (Date.now() - epoch > heartbeatInterval) {
-        return true;
-      }
+    if (isDefined(epoch) && Date.now() - epoch > this.heartbeatInterval) {
+      return true;
     }
     return false;
   }
 };
-SimpleBlockRunner = _ts_decorate5([
-  creatableProvider4()
+SimpleBlockRunner = _ts_decorate4([
+  creatableProvider3()
 ], SimpleBlockRunner);
 
-// src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
-import { exists as exists3, filterAs as filterAs2 } from "@xylabs/sdk-js";
-import { isBoundWitness } from "@xyo-network/boundwitness-model";
-import { payloadSchemasContains } from "@xyo-network/boundwitness-validator";
-import { BoundWitnessWrapper } from "@xyo-network/boundwitness-wrapper";
-import { asChainStakeIntent, ChainStakeIntentSchema } from "@xyo-network/xl1-sdk";
-var getBlockSignedStakeDeclarations = /* @__PURE__ */ __name(async (block, archivist, intent) => {
-  const blockData = await archivist.get(block.payload_hashes);
-  const bwsFromBlock = blockData.filter((x) => isBoundWitness(x));
-  const bwsFromBlockWithDeclarations = bwsFromBlock.filter((bw) => payloadSchemasContains(bw, ChainStakeIntentSchema));
-  const validBlockBwsWithDeclarations = await filterToValidSignedBoundWitnesses(bwsFromBlockWithDeclarations);
-  return (await Promise.all(validBlockBwsWithDeclarations.map(async (bw) => {
-    const stakeIntentHashes = validBlockBwsWithDeclarations.flatMap(mapBoundWitnessToStakeIntentHashes).filter(exists3);
-    const payloads = await archivist.get(stakeIntentHashes);
-    const stakeIntents = filterAs2(payloads, asChainStakeIntent).filter((p) => p.intent === intent).filter((p) => bw.addresses.includes(p.from));
-    return stakeIntents;
-  }))).flat();
-}, "getBlockSignedStakeDeclarations");
-var filterToValidSignedBoundWitnesses = /* @__PURE__ */ __name(async (bws) => {
-  const validBwIndexes = await Promise.all(bws.map((bw) => BoundWitnessWrapper.parse(bw).getValid()));
-  return bws.filter((_, index) => validBwIndexes[index]);
-}, "filterToValidSignedBoundWitnesses");
-var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
-  return bw.payload_schemas.map((schema, index) => schema === ChainStakeIntentSchema ? bw.payload_hashes[index] : void 0);
-}, "mapBoundWitnessToStakeIntentHashes");
-
-// src/StakeIntent/XyoStakeIntentService.ts
-import { asAddress, assertEx as assertEx6, filterAs as filterAs3, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
-import { analyzeChain, ChainStakeIntentAnalyzer, isChainSummaryStakeIntent } from "@xyo-network/chain-analyze";
-import { DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS, findFirstMatching, IntervalMap } from "@xyo-network/chain-utils";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
-import { AbstractCreatableProvider as AbstractCreatableProvider6, asChainIndexingServiceStateWithStorageMeta, BlockViewerMoniker as BlockViewerMoniker2, ChainIndexingServiceStateSchema, ChainStakeViewerMoniker, creatableProvider as creatableProvider5, isChainIndexingServiceState, readPayloadMapFromStore, timeBudget } from "@xyo-network/xl1-sdk";
-import { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta, asChainStakeIntent as asChainStakeIntent2 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex2 } from "async-mutex";
-import { LRUCache } from "lru-cache";
-function _ts_decorate6(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate6, "_ts_decorate");
-var ACTIVE_STAKE_TTL = 1e3 * 60 * 60 * 2;
-var NO_ACTIVE_STAKE_TTL = 1e3 * 2;
-var STAKE_CACHE_MAX_ENTRIES = 1e4;
-var XyoStakeIntentService = class _XyoStakeIntentService extends AbstractCreatableProvider6 {
-  static {
-    __name(this, "XyoStakeIntentService");
-  }
-  static defaultMoniker = "StakeIntent";
-  static dependencies = [];
-  static monikers = [
-    _XyoStakeIntentService.defaultMoniker
-  ];
-  moniker = "StakeIntent";
-  // TODO: Use hash instead of block number to handle chain reorgs
-  _lastIndexedBlockHash = void 0;
-  // TODO: Interval tree per declaration (bank, validator, etc.)
-  // Ideally move to DataIntervalTree to handle declared
-  // ranges as it enables range queries in O(min(n, k * log n)) time,
-  // where k is the number of intervals in the output list time
-  // Currently using set based because it's simpler, equivalent
-  // in performance for small sets, and (most importantly) easily
-  // persisted so we can recover state on restart.
-  _producers = new IntervalMap();
-  _stakeCache = new LRUCache({
-    max: STAKE_CACHE_MAX_ENTRIES
-  });
-  _updateMutex = new Mutex2();
-  _blockViewer;
-  _chainStakeViewer;
-  get blockViewer() {
-    return this._blockViewer;
-  }
-  get chainArchivist() {
-    return assertEx6(this.params.chainArchivist, () => "chainArchivist not set");
-  }
-  get chainStakeViewer() {
-    return this._chainStakeViewer;
-  }
-  get stakeIntentStateArchivist() {
-    return assertEx6(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
-  }
-  static async paramsHandler(params) {
-    return {
-      ...await super.paramsHandler(params),
-      chainArchivist: assertEx6(params?.chainArchivist, () => "chainArchivist is required"),
-      stakeIntentStateArchivist: assertEx6(params?.stakeIntentStateArchivist, () => "stakeIntentStateArchivist is required")
-    };
-  }
-  async createHandler() {
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker2);
-    this._chainStakeViewer = await this.locator.getInstance(ChainStakeViewerMoniker);
-    const head = await this.blockViewer.currentBlock();
-    if (isUndefined2(head)) return;
-    await this.recoverState(head[0]._hash);
-  }
-  async getDeclaredCandidateRanges(address, intent) {
-    await Promise.resolve();
-    assertEx6(intent === "producer", () => `Support not yet added for intent ${intent}`);
-    const results = this._producers.get(address);
-    return results ?? [];
-  }
-  async getDeclaredCandidatesForBlock(block, intent) {
-    return await this.spanAsync("getDeclaredCandidatesForBlock", async () => {
-      assertEx6(intent === "producer", () => `Support not yet added for intent ${intent}`);
-      const results = this._producers.findAllContaining(block);
-      const candidates = [
-        ...results
-      ];
-      const requiredMinimumStake = this.getRequiredMinimumStakeForIntent(intent);
-      const validCandidates = await this.filterToValidStake(candidates, this.chainStakeViewer, requiredMinimumStake);
-      return validCandidates;
-    }, this.context);
-  }
-  getRequiredMinimumStakeForIntent(intent) {
-    switch (intent) {
-      case "producer": {
-        const { minStake } = this.params.context.config.actors.producer;
-        return BigInt(minStake);
-      }
-    }
-  }
-  async isStakedForBlock(block, intent, address) {
-    const candidates = await this.getDeclaredCandidatesForBlock(block, intent);
-    return candidates.includes(address);
-  }
-  async startHandler() {
-    await this.updateIndex(true);
-  }
-  async filterToValidStake(candidates, chainStakeViewer, requiredMinimumStake) {
-    const candidatesWithStake = await Promise.all(candidates.map(async (candidate) => {
-      const stake = this._stakeCache.get(candidate);
-      if (stake === void 0) {
-        const activeStake = await chainStakeViewer.activeByStaked(candidate);
-        if (activeStake > 0n) {
-          this._stakeCache.set(candidate, activeStake, {
-            ttl: ACTIVE_STAKE_TTL
-          });
-        } else {
-          this._stakeCache.set(candidate, activeStake, {
-            ttl: NO_ACTIVE_STAKE_TTL
-          });
-        }
-        return {
-          candidate,
-          stake: activeStake
-        };
-      } else {
-        return {
-          candidate,
-          stake
-        };
-      }
-    }));
-    return candidatesWithStake.filter(({ stake }) => stake >= requiredMinimumStake).map(({ candidate }) => candidate);
-  }
-  async persistState(current) {
-    const state = this._producers.serialize();
-    const payload = new PayloadBuilder5({
-      schema: ChainIndexingServiceStateSchema
-    }).fields({
-      endBlockHash: current,
-      state
-    }).build();
-    await this.stakeIntentStateArchivist.insert([
-      payload
-    ]);
-  }
-  async recoverState(current) {
-    return await timeBudget("XyoStakeIntentService.recoverState", console, async () => {
-      const currentBlock = assertEx6(asBlockBoundWitness2((await this.chainArchivist.get([
-        current
-      ]))?.[0]), () => `Block ${current} not found`);
-      const currentBlockNum = currentBlock.block;
-      const opts = {
-        ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS
-      };
-      while (true) {
-        const predicate = /* @__PURE__ */ __name((p) => {
-          const state2 = asChainIndexingServiceStateWithStorageMeta(p);
-          return state2 ? true : false;
-        }, "predicate");
-        const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts);
-        if (isChainIndexingServiceState(state)) {
-          const indexed = (await this.chainArchivist.get([
-            state.endBlockHash
-          ]))?.[0];
-          const indexedBlock = asBlockBoundWitnessWithStorageMeta(indexed);
-          if (indexedBlock) {
-            const indexedBlockNum = indexedBlock.block;
-            if (indexedBlockNum <= currentBlockNum) {
-              const data = state.state;
-              this._producers = new IntervalMap(data);
-              this._lastIndexedBlockHash = indexedBlock._hash;
-              break;
-            }
-          }
-        } else {
-          break;
-        }
-        opts.open = true;
-      }
-    }, 2e3, true);
-  }
-  async updateIndex(displayProgress = false) {
-    if (this._updateMutex.isLocked()) {
-      return;
-    }
-    await this._updateMutex.runExclusive(async () => {
-      return await this.spanAsync("updateIndex", async () => {
-        const currentHead = (await this.blockViewer.currentBlock())[0];
-        if (isUndefined2(currentHead)) return;
-        const currentHeadHash = currentHead._hash;
-        const chainMap = readPayloadMapFromStore(this.chainArchivist);
-        const result = await analyzeChain({
-          ...this.context,
-          chainMap
-        }, [
-          new ChainStakeIntentAnalyzer("producer")
-        ], currentHeadHash, this._lastIndexedBlockHash);
-        const signedDeclarations = filterAs3(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
-        if (currentHead.block === void 0) return;
-        const currentHeadBlockNum = currentHead.block;
-        if (displayProgress) this.logger?.log(`Updating index through 0x${currentHeadBlockNum}`);
-        for (const signedDeclaration of signedDeclarations) {
-          const { exp, nbf } = signedDeclaration;
-          const start = nbf;
-          const stop = exp;
-          const address = asAddress(signedDeclaration?.from);
-          if (start !== void 0 && stop !== void 0 && address !== void 0) {
-            this._producers.insert(address, start, stop);
-          }
-        }
-        this._lastIndexedBlockHash = currentHeadHash;
-      }, this.context);
-    });
-  }
-};
-XyoStakeIntentService = _ts_decorate6([
-  creatableProvider5()
-], XyoStakeIntentService);
-
 // src/StepStake/BaseStepStakeService.ts
-import { AbstractCreatableProvider as AbstractCreatableProvider7, StepStakeViewerMoniker } from "@xyo-network/xl1-sdk";
-var AbstractStepStakeService = class _AbstractStepStakeService extends AbstractCreatableProvider7 {
+import { AbstractCreatableProvider as AbstractCreatableProvider5, StepStakeViewerMoniker } from "@xyo-network/xl1-sdk";
+var AbstractStepStakeService = class _AbstractStepStakeService extends AbstractCreatableProvider5 {
   static {
     __name(this, "AbstractStepStakeService");
   }
@@ -1110,15 +567,12 @@ export {
   AbstractStepStakeService,
   BaseElectionService,
   BaseNetworkStakeStepRewardService,
-  BasePendingTransactionsService,
   DEFAULT_BLOCK_SIZE,
   EvmBlockRewardViewer,
   SimpleBlockRunner,
   XYO_PRODUCER_REDECLARATION_DURATION,
   XYO_PRODUCER_REDECLARATION_WINDOW,
-  XyoStakeIntentService,
   XyoValidator,
-  createBootstrapHead,
-  getBlockSignedStakeDeclarations
+  createBootstrapHead
 };
 //# sourceMappingURL=index.mjs.map