@xyo-network/chain-services 1.5.28 → 1.5.30

package/dist/neutral/index.mjs

@@ -30,6 +30,7 @@ var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist
         isPositiveBigInt(value) ? value.positive : "0"
       ]));
     }, "getBalances"),
+    name: "ArchivistAccountBalanceService",
     async sync(head2) {
       const analysis = await analyzeChain(archivist, [
         new BalanceAnalyzer()
@@ -58,8 +59,9 @@ var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist
 // src/AccountBalance/XyoChainAccountBalanceService.ts
 import { assertEx } from "@xylabs/assert";
 import { toHex } from "@xylabs/hex";
-import { analyzeChain as analyzeChain2, BalanceAnalyzer as BalanceAnalyzer2, isChainSummaryBalances as isChainSummaryBalances2 } from "@xyo-network/chain-analyze";
+import { analyzeChain as analyzeChain2, BalanceAnalyzer as BalanceAnalyzer2, ChainSummaryBalancesSchema as ChainSummaryBalancesSchema2, isChainSummaryBalances as isChainSummaryBalances2 } from "@xyo-network/chain-analyze";
 import { toPositiveBigInt } from "@xyo-network/chain-protocol";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
 
 // src/BaseService.ts
 import { BaseEmitter } from "@xylabs/events";
@@ -123,7 +125,14 @@ var XyoChainAccountBalanceService = class extends BaseService {
     __name(this, "XyoChainAccountBalanceService");
   }
   _balances = {};
-  _previousHead = null;
+  /**
+  * The most recent head that was indexed to
+  */
+  _firstBlock = null;
+  /**
+  * The oldest block that was indexed through
+  */
+  _lastBlock = null;
   get chainArchivist() {
     return assertEx(this.params.chainArchivist, () => "chainArchivist is required");
   }
@@ -141,170 +150,30 @@ var XyoChainAccountBalanceService = class extends BaseService {
     return result;
   }
   async sync(head) {
+    const startingBalances = new PayloadBuilder({
+      schema: ChainSummaryBalancesSchema2
+    }).fields({
+      balances: this._balances,
+      firstBlock: this._firstBlock,
+      lastBlock: this._lastBlock
+    }).build();
     const analysis = await analyzeChain2(this.chainArchivist, [
-      new BalanceAnalyzer2()
-    ], head, this._previousHead, -1n, this.tracer);
-    this._balances = assertEx(analysis.find(isChainSummaryBalances2)?.balances, () => "Failed to sync balances");
+      new BalanceAnalyzer2(void 0, void 0, startingBalances)
+    ], head, this._firstBlock);
+    const allAddressesBalances = analysis.find(isChainSummaryBalances2);
+    if (allAddressesBalances === void 0) return;
+    this._balances = {
+      ...this._balances,
+      ...allAddressesBalances.balances
+    };
+    this._firstBlock = allAddressesBalances.firstBlock;
+    if (this._lastBlock === null) this._lastBlock = allAddressesBalances.lastBlock;
   }
 };
 XyoChainAccountBalanceService = _ts_decorate([
   creatableService()
 ], XyoChainAccountBalanceService);
 
-// src/BaseEthProvider.ts
-var BaseEthProvider = class {
-  static {
-    __name(this, "BaseEthProvider");
-  }
-  eth_accounts() {
-    throw new Error("Method not implemented.");
-  }
-  eth_blockNumber() {
-    throw new Error("Method not implemented.");
-  }
-  eth_call(_transaction, _blockNumber) {
-    throw new Error("Method not implemented.");
-  }
-  eth_clearSubscriptions(_keepSyncing) {
-    throw new Error("Method not implemented.");
-  }
-  eth_coinbase() {
-    throw new Error("Method not implemented.");
-  }
-  eth_compileLLL(_code) {
-    throw new Error("Method not implemented.");
-  }
-  eth_compileSerpent(_code) {
-    throw new Error("Method not implemented.");
-  }
-  eth_compileSolidity(_code) {
-    throw new Error("Method not implemented.");
-  }
-  eth_estimateGas(_transaction, _blockNumber) {
-    throw new Error("Method not implemented.");
-  }
-  eth_feeHistory(_blockCount, _newestBlock, _rewardPercentiles) {
-    throw new Error("Method not implemented.");
-  }
-  eth_gasPrice() {
-    throw new Error("Method not implemented.");
-  }
-  eth_getBalance(_address, _blockNumber) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getBlockByHash(_blockHash, _hydrated) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getBlockByNumber(_blockNumber, _hydrated) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getBlockTransactionCountByHash(_blockHash) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getBlockTransactionCountByNumber(_blockNumber) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getCode(_address, _blockNumber) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getCompilers() {
-    throw new Error("Method not implemented.");
-  }
-  eth_getFilterChanges(_filterIdentifier) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getFilterLogs(_filterIdentifier) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getLogs(_filter) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getStorageAt(_address, _storageSlot, _blockNumber) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getTransactionByBlockHashAndIndex(_blockHash, _transactionIndex) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getTransactionByBlockNumberAndIndex(_blockNumber, _transactionIndex) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getTransactionByHash(_transactionHash) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getTransactionCount(_address, _blockNumber) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getTransactionReceipt(_transactionHash) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getUncleByBlockHashAndIndex(_blockHash, _uncleIndex) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getUncleByBlockNumberAndIndex(_blockNumber, _uncleIndex) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getUncleCountByBlockHash(_blockHash) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getUncleCountByBlockNumber(_blockNumber) {
-    throw new Error("Method not implemented.");
-  }
-  eth_getWork() {
-    throw new Error("Method not implemented.");
-  }
-  eth_hashrate() {
-    throw new Error("Method not implemented.");
-  }
-  eth_maxPriorityFeePerGas() {
-    throw new Error("Method not implemented.");
-  }
-  eth_mining() {
-    throw new Error("Method not implemented.");
-  }
-  eth_newBlockFilter() {
-    throw new Error("Method not implemented.");
-  }
-  eth_newFilter(_filter) {
-    throw new Error("Method not implemented.");
-  }
-  eth_newPendingTransactionFilter() {
-    throw new Error("Method not implemented.");
-  }
-  eth_protocolVersion() {
-    throw new Error("Method not implemented.");
-  }
-  eth_sendRawTransaction(_transaction) {
-    throw new Error("Method not implemented.");
-  }
-  eth_sendTransaction(_transaction) {
-    throw new Error("Method not implemented.");
-  }
-  eth_sign(_address, _message) {
-    throw new Error("Method not implemented.");
-  }
-  eth_signTransaction(_transaction) {
-    throw new Error("Method not implemented.");
-  }
-  eth_submitHashrate(_hashRate, _id) {
-    throw new Error("Method not implemented.");
-  }
-  eth_submitWork(_nonce, _hash, _digest) {
-    throw new Error("Method not implemented.");
-  }
-  eth_subscribe(..._params) {
-    throw new Error("Method not implemented.");
-  }
-  eth_syncing() {
-    throw new Error("Method not implemented.");
-  }
-  eth_uninstallFilter(_filterIdentifier) {
-    throw new Error("Method not implemented.");
-  }
-  eth_unsubscribe(_subscriptionId) {
-    throw new Error("Method not implemented.");
-  }
-};
-
 // src/BlockProducer/XyoBlockProducer.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
 import { exists } from "@xylabs/exists";
@@ -312,7 +181,7 @@ import { hexToBigInt, toHex as toHex2 } from "@xylabs/hex";
 import { isUndefined } from "@xylabs/typeof";
 import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
 import { buildBlock } from "@xyo-network/chain-protocol";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 import { asBlockBoundWitness, BlockNumberSchema, ChainStakeIntentSchema } from "@xyo-network/xl1-protocol";
 
 // src/BlockProducer/generateTransactionFeeTransfers.ts
@@ -394,8 +263,8 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
   get pendingTransactionsService() {
     return assertEx3(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
   }
-  get rejectedBundledTransactionsArchivist() {
-    return assertEx3(this.params.rejectedBundledTransactionsArchivist, () => "No rejected bundled transactions archivist");
+  get rejectedTransactionsArchivist() {
+    return assertEx3(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
   }
   get rewardAddress() {
     return assertEx3(this.params.rewardAddress, () => "No reward address provided");
@@ -428,7 +297,7 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
       });
     }
     const blockHex = assertEx3(toHex2(block), () => "Failed to convert block to hex");
-    const blockId = new PayloadBuilder({
+    const blockId = new PayloadBuilder2({
       schema: BlockNumberSchema
     }).fields({
       block: blockHex
@@ -454,7 +323,7 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
     const currentBlock = head.block;
     const timeToProducerExpiration = currentDeclarationEnd - currentBlock;
     if (timeToProducerExpiration > XYO_PRODUCER_RESTAKE_WINDOW) return;
-    const intent = new PayloadBuilder({
+    const intent = new PayloadBuilder2({
       schema: ChainStakeIntentSchema
     }).fields({
       from: this.address,
@@ -502,7 +371,7 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
       if (errors.length > 0) {
         this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`);
         const rejectedTransactions = block[1];
-        await this.rejectedBundledTransactionsArchivist.insert(rejectedTransactions);
+        await this.rejectedTransactionsArchivist.insert(rejectedTransactions);
       } else {
         return block;
       }
@@ -616,9 +485,96 @@ XyoBlockRewardService = _ts_decorate4([
   ])
 ], XyoBlockRewardService);
 
-// src/ChainValidator/XyoValidator.ts
+// src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
 import { assertEx as assertEx6 } from "@xylabs/assert";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { isDefined as isDefined2, isNull } from "@xylabs/typeof";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness as asBlockBoundWitness2, asOptionalBlockBoundWitness, isBlockBoundWitness } from "@xyo-network/xl1-protocol";
+import { LRUCache } from "lru-cache";
+var ChainBlockNumberIterationService = class extends BaseService {
+  static {
+    __name(this, "ChainBlockNumberIterationService");
+  }
+  _blocksByBlockNumber = new LRUCache({
+    max: 1e4
+  });
+  get chainArchivist() {
+    return assertEx6(this.params.chainArchivist);
+  }
+  get chainIdentification() {
+    return {
+      id: assertEx6(this.params.head?.chain)
+    };
+  }
+  async get(block) {
+    const head = await this.head();
+    assertEx6(head.block >= block, () => `Block requested is newer than the current head [${block}]`);
+    const cached = this._blocksByBlockNumber.get(block);
+    if (cached) return cached;
+    const startingBlock = head;
+    const currentBlockHash = await PayloadBuilder3.hash(startingBlock);
+    let currentBlock = (await this.chainArchivist.get([
+      currentBlockHash
+    ])).at(0);
+    while (isDefined2(currentBlock)) {
+      assertEx6(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
+      if (isBlockBoundWitness(currentBlock)) {
+        this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
+        if (currentBlock.block === block) {
+          return currentBlock;
+        }
+        const { previous } = currentBlock;
+        if (isNull(previous)) break;
+        currentBlock = (await this.chainArchivist.get([
+          previous
+        ])).at(0);
+      }
+    }
+    throw new Error(`Block not found: ${block}`);
+  }
+  async head() {
+    return await Promise.resolve(assertEx6(this.params.head));
+  }
+  async next(block) {
+    const currentBlock = block;
+    const nextBlockNumber = currentBlock + 1;
+    return await this.get(nextBlockNumber);
+  }
+  // TODO: Decide on inclusive/exclusive (probably need inclusive to account for chain head)
+  // and then communicate via method name and documentation
+  async previous(block = void 0, count = 1) {
+    const results = [];
+    let currentBlock = isDefined2(block) ? await this.get(block) : await this.head();
+    while (currentBlock && results.length < count) {
+      if (isBlockBoundWitness(currentBlock)) {
+        results.push(currentBlock);
+        const { previous } = currentBlock;
+        if (isNull(previous)) break;
+        const nextBlock = await this.chainArchivist.get([
+          previous
+        ]);
+        currentBlock = asOptionalBlockBoundWitness(nextBlock[0]);
+      } else {
+        const hash = PayloadBuilder3.hash(currentBlock);
+        assertEx6(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
+      }
+    }
+    return results;
+  }
+  async updateHead(head) {
+    await Promise.resolve();
+    this.params.head = head;
+    void this.emit("headUpdated", {
+      blocks: [
+        head
+      ]
+    });
+  }
+};
+
+// src/ChainValidator/XyoValidator.ts
+import { assertEx as assertEx7 } from "@xylabs/assert";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 function _ts_decorate5(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);
@@ -628,8 +584,8 @@ function _ts_decorate5(decorators, target, key, desc) {
 __name(_ts_decorate5, "_ts_decorate");
 var addStorageMeta = /* @__PURE__ */ __name(async ([tx, payloads]) => {
   return [
-    await PayloadBuilder2.addStorageMeta(tx),
-    await PayloadBuilder2.addStorageMeta(payloads)
+    await PayloadBuilder4.addStorageMeta(tx),
+    await PayloadBuilder4.addStorageMeta(payloads)
   ];
 }, "addStorageMeta");
 var XyoValidator = class extends BaseService {
@@ -640,22 +596,22 @@ var XyoValidator = class extends BaseService {
     return this.account.address;
   }
   get account() {
-    return assertEx6(this.params.account, () => "account is required");
+    return assertEx7(this.params.account, () => "account is required");
   }
   get chainArchivist() {
-    return assertEx6(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx7(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainInfo() {
-    return assertEx6(this.params.chainInformation, () => "chainInfo is required");
+    return assertEx7(this.params.chainInformation, () => "chainInfo is required");
   }
   get electionService() {
-    return assertEx6(this.params.electionService, () => "electionService is required");
+    return assertEx7(this.params.electionService, () => "electionService is required");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx6(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
+    return assertEx7(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
   }
   get rewardService() {
-    return assertEx6(this.params.rewardService, () => "rewardService is required");
+    return assertEx7(this.params.rewardService, () => "rewardService is required");
   }
   validatePendingBlock(_block) {
     return [];
@@ -674,9 +630,9 @@ XyoValidator = _ts_decorate5([
 ], XyoValidator);
 
 // src/Election/XyoElectionService.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
+import { assertEx as assertEx8 } from "@xylabs/assert";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 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);
@@ -696,19 +652,19 @@ var XyoElectionService = class extends BaseService {
     super(params);
   }
   get chainIterator() {
-    return assertEx7(this.params.chainIterator, () => "No chain iterator");
+    return assertEx8(this.params.chainIterator, () => "No chain iterator");
   }
   get chainStakeViewer() {
-    return assertEx7(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx8(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx7(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx8(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
       const nextBlock = current.block + 1;
       const candidates = await this.stakeIntentService.getDeclaredCandidatesForBlock(nextBlock, "producer");
-      const previousBlockHash = await PayloadBuilder3.hash(current);
+      const previousBlockHash = await PayloadBuilder5.hash(current);
       return this.generateCreatorCommittee(candidates, previousBlockHash);
     });
   }
@@ -730,34 +686,56 @@ XyoElectionService = _ts_decorate6([
 // src/PendingTransactions/PendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
 import { filterAsync } from "@xylabs/array";
-import { assertEx as assertEx8 } from "@xylabs/assert";
+import { assertEx as assertEx9 } from "@xylabs/assert";
 import { exists as exists2 } from "@xylabs/exists";
 import { forget } from "@xylabs/forget";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
 import { globalAttributes } from "@xyo-network/chain-telemetry";
 import { validateTransaction } from "@xyo-network/chain-validation";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { asOptionalTransactionBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
-import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { asOptionalTransactionBoundWitnessWithStorageMeta as asOptionalTransactionBoundWitnessWithStorageMeta2, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 import { Mutex as Mutex2 } from "async-mutex";
-function _ts_decorate7(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_decorate7, "_ts_decorate");
-async function bundledPayloadsToHydratedTransaction(payload) {
-  const withStorageMeta = await PayloadBuilder4.addStorageMeta(payload.payloads);
+
+// src/PendingTransactions/bundledPayloadToHydratedTransaction.ts
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { asOptionalTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
+  const withStorageMeta = await PayloadBuilder6.addStorageMeta(payload.payloads);
   const tx = asOptionalTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
       tx,
-      withStorageMeta.map((p) => p._hash === payload.root ? void 0 : p).filter(exists2)
+      withStorageMeta.filter((p) => p._hash !== payload.root)
     ];
   }
+}, "bundledPayloadToHydratedTransaction");
+
+// src/PendingTransactions/hydratedTransactionToPayloadBundle.ts
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { PayloadBundleSchema } from "@xyo-network/payload-model";
+import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
+var hydratedTransactionWithHashStorageMetaToPayloadBundle = /* @__PURE__ */ __name((transaction) => {
+  const root = transaction[0]._hash;
+  return bundle(root, transaction);
+}, "hydratedTransactionWithHashStorageMetaToPayloadBundle");
+var bundle = /* @__PURE__ */ __name((root, transaction) => {
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder7.omitStorageMeta(p));
+  return new PayloadBuilder7({
+    schema: PayloadBundleSchema
+  }).fields({
+    payloads,
+    root
+  }).build();
+}, "bundle");
+
+// src/PendingTransactions/PendingTransactions.ts
+function _ts_decorate7(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(bundledPayloadsToHydratedTransaction, "bundledPayloadsToHydratedTransaction");
+__name(_ts_decorate7, "_ts_decorate");
 globalAttributes.setAttribute("XyoPendingTransactionsService:status", "unknown");
 var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends BaseService {
   static {
@@ -795,6 +773,11 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
   * 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
@@ -802,23 +785,23 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
   */
   _updateCuratedPendingTransactionsArchivistMutex = new Mutex2();
   get chainArchivist() {
-    return assertEx8(this.params.chainArchivist, () => "No completed blocks with data archivist");
+    return assertEx9(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get chainIdentification() {
-    return assertEx8(this.params.chainIdentification, () => "No chain id");
+    return assertEx9(this.params.chainIdentification, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx8(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx8(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+    return assertEx9(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
   }
   get pendingTransactionsCount() {
     forget(this.countPendingTransactions());
     return this._pendingTransactionsCount;
   }
-  get rejectedBundledTransactionsArchivist() {
-    return assertEx8(this.params.rejectedBundledTransactionsArchivist, () => "No rejected bundled transactions archivist");
+  get rejectedTransactionsArchivist() {
+    return assertEx9(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
@@ -829,10 +812,10 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
       await this.insertNewTransactions(payloads);
     });
     this.chainArchivist.on("inserted", ({ payloads }) => {
-      this.removeFinalizedTransactions(payloads);
+      this.markAnyIncludedTransactionsForRemoval(payloads);
     });
-    this.rejectedBundledTransactionsArchivist.on("inserted", ({ payloads }) => {
-      this.removeRejectedBundledTransactions(payloads);
+    this.rejectedTransactionsArchivist.on("inserted", ({ payloads }) => {
+      this.markAnyIncludedTransactionsForRemoval(payloads);
     });
     const pendingTransactionsCounter = this.meter?.createObservableUpDownCounter("xyo_pending_transactions_counter", {
       description: "The current number of pending transactions",
@@ -861,13 +844,13 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
           const deletedTransactionBundles = payloads.filter((tx) => this._removablePendingTransactionHashes.has(tx.root));
           foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists2));
           const undeletedTransactionBundles = payloads.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-          const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadsToHydratedTransaction(p)))).filter(exists2);
+          const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
           foundPendingTransactions.push(...transactions);
         }
+        await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes);
         for (const hash of foundPendingTransactionsToDeleteHashes) {
           this._removablePendingTransactionHashes.delete(hash);
         }
-        await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes);
         return foundPendingTransactions;
       }, _XyoPendingTransactionsService.MutexPriority.ReadTransactions);
     });
@@ -887,12 +870,13 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
     return nonFinalizedTransactions;
   }
   async insertNewTransactions(payloads) {
+    if (payloads.length === 0) return;
     this.logger?.log("insertNewTransactions", payloads);
     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 bundledPayloadsToHydratedTransaction(tx);
+          return await bundledPayloadToHydratedTransaction(tx);
         }))).filter(exists2);
         const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
           const errors = await validateTransaction(tx, this.chainIdentification.id);
@@ -902,40 +886,36 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
           return errors.length > 0 ? false : true;
         });
         if (validTransactions.length > 0) {
-          await this.pendingBundledTransactionsLocalArchivist.insert(validTransactions.map((tx) => {
-            return {
-              root: tx[0]._hash,
-              payloads: flattenHydratedTransaction(tx)
-            };
-          }));
+          const bundledTransactions = validTransactions.map((tx) => hydratedTransactionWithHashStorageMetaToPayloadBundle(tx));
+          await this.pendingBundledTransactionsLocalArchivist.insert(bundledTransactions);
         }
       }, _XyoPendingTransactionsService.MutexPriority.InsertNewTransactions);
     });
   }
+  /**
+  * 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 removeBundledTransactions(bundledPayloads, priority) {
     return await this.spanAsync(priority, async () => {
       return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
         const bundledTransactions = (await Promise.all(bundledPayloads.map(async (payload) => {
-          const withStorageMeta = await PayloadBuilder4.addStorageMeta(payload.payloads);
-          const tx = asOptionalTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
+          const withStorageMeta = await PayloadBuilder8.addStorageMeta(payload.payloads);
+          const tx = asOptionalTransactionBoundWitnessWithStorageMeta2(withStorageMeta.find((p) => p._hash === payload.root));
           return tx !== void 0 && payload._hash !== void 0 ? tx : void 0;
         }))).filter(exists2);
         await this.pendingBundledTransactionsLocalArchivist.delete(bundledTransactions.map((btx) => btx._hash));
       }, _XyoPendingTransactionsService.MutexPriority[priority]);
     });
   }
-  removeFinalizedTransactions(payloads) {
-    const finalizedTransactionHashes = payloads.filter(isTransactionBoundWitnessWithStorageMeta).map((p) => p._hash);
-    for (const hash of finalizedTransactionHashes) {
-      this._removablePendingTransactionHashes.add(hash);
-    }
-  }
-  removeRejectedBundledTransactions(payloads) {
-    const rejectedTransactionHashes = payloads.filter(isTransactionBoundWitnessWithStorageMeta).map((p) => p._hash);
-    for (const hash of rejectedTransactionHashes) {
-      this._removablePendingTransactionHashes.add(hash);
-    }
-  }
 };
 XyoPendingTransactionsService = _ts_decorate7([
   creatableService()
@@ -970,14 +950,14 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 
 // src/StakeIntent/XyoStakeIntentService.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
-import { assertEx as assertEx9 } from "@xylabs/assert";
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { asAddress } from "@xylabs/hex";
 import { analyzeChain as analyzeChain3, 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 { asOptionalBlockBoundWitness, asOptionalBlockBoundWitnessWithStorageMeta, asOptionalChainIndexingServiceStateWithStorageMeta, asOptionalChainStakeIntent as asOptionalChainStakeIntent2, ChainIndexingServiceStateSchema, isChainIndexingServiceState } from "@xyo-network/xl1-protocol";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { asChainIndexingServiceStateWithStorageMeta, asOptionalBlockBoundWitness as asOptionalBlockBoundWitness2, asOptionalBlockBoundWitnessWithStorageMeta, asOptionalChainStakeIntent as asOptionalChainStakeIntent2, ChainIndexingServiceStateSchema, isChainIndexingServiceState } from "@xyo-network/xl1-protocol";
 import { Mutex as Mutex3 } from "async-mutex";
-import { LRUCache } from "lru-cache";
+import { LRUCache as LRUCache2 } from "lru-cache";
 function _ts_decorate8(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);
@@ -1006,7 +986,7 @@ var XyoStakeIntentService = class extends BaseService {
   // in performance for small sets, and (most importantly) easily
   // persisted so we can recover state on restart.
   _producers = new IntervalMap();
-  _stakeCache = new LRUCache({
+  _stakeCache = new LRUCache2({
     max: STAKE_CACHE_MAX_ENTRIES
   });
   _updateMutex = new Mutex3();
@@ -1017,33 +997,33 @@ var XyoStakeIntentService = class extends BaseService {
     });
   }
   get chainArchivist() {
-    return assertEx9(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx10(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainIterator() {
-    return assertEx9(this.params.chainIterator, () => "chainIterator not set");
+    return assertEx10(this.params.chainIterator, () => "chainIterator not set");
   }
   get chainStakeViewer() {
-    return assertEx9(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx10(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx9(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx10(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
     const head = await this.chainIterator.head();
-    const headHash = await PayloadBuilder5.hash(head);
+    const headHash = await PayloadBuilder9.hash(head);
     if (head?.block === void 0) return;
     await this.recoverState(headHash);
     await this.updateIndex(true);
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx9(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+    assertEx10(intent === "producer", () => `Error: 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 () => {
-      assertEx9(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+      assertEx10(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
       const candidates = [
         ...results
@@ -1085,7 +1065,7 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async persistState(current) {
     const state = this._producers.serialize();
-    const payload = new PayloadBuilder5({
+    const payload = new PayloadBuilder9({
       schema: ChainIndexingServiceStateSchema
     }).fields({
       endBlockHash: current,
@@ -1096,7 +1076,7 @@ var XyoStakeIntentService = class extends BaseService {
     ]);
   }
   async recoverState(current) {
-    const currentBlock = assertEx9(asOptionalBlockBoundWitness((await this.chainArchivist.get([
+    const currentBlock = assertEx10(asOptionalBlockBoundWitness2((await this.chainArchivist.get([
       current
     ]))?.[0]), () => `Block ${current} not found`);
     const currentBlockNum = currentBlock.block;
@@ -1105,7 +1085,7 @@ var XyoStakeIntentService = class extends BaseService {
     };
     while (true) {
       const predicate = /* @__PURE__ */ __name((p) => {
-        const state2 = asOptionalChainIndexingServiceStateWithStorageMeta(p);
+        const state2 = asChainIndexingServiceStateWithStorageMeta(p);
         return state2 ? true : false;
       }, "predicate");
       const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts);
@@ -1136,7 +1116,7 @@ var XyoStakeIntentService = class extends BaseService {
     await this._updateMutex.runExclusive(async () => {
       return await this.spanAsync("updateIndex", async () => {
         const currentHead = await this.chainIterator.head();
-        const currentHeadHash = await PayloadBuilder5.hash(currentHead);
+        const currentHeadHash = await PayloadBuilder9.hash(currentHead);
         const result = await analyzeChain3(this.chainArchivist, [
           new ChainStakeIntentAnalyzer("producer")
         ], currentHeadHash, this._lastIndexedBlockHash);
@@ -1167,200 +1147,89 @@ XyoStakeIntentService = _ts_decorate8([
 ], XyoStakeIntentService);
 
 // src/Staker/Evm/Evm.ts
-import { Base } from "@xylabs/base";
+import { assertEx as assertEx11 } from "@xylabs/assert";
 import { toAddress } from "@xylabs/hex";
+import { toEthAddress as toEthAddress2 } from "@xyo-network/chain-ethereum";
 import { StakedXyoChain__factory as StakedXyoChainFactory } from "@xyo-network/typechain";
 import { getAddress } from "ethers/address";
-var EvmChainService = class extends Base {
+var EvmChainService = class extends BaseService {
   static {
     __name(this, "EvmChainService");
   }
-  _contract;
-  constructor(params) {
-    super(params);
-    this._contract = params.contract;
+  get contract() {
+    if (this.params.contract === void 0) {
+      this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(this.id), this.params.runner);
+    }
+    return assertEx11(this.params.contract);
   }
   get id() {
-    return this.params.id;
+    return assertEx11(this.params.id);
   }
   get runner() {
-    return this.params.runner;
-  }
-  static create({ id, runner, logger, traceProvider, meterProvider }) {
-    const contractAddress = getAddress(id);
-    const contract = StakedXyoChainFactory.connect(contractAddress, runner);
-    return new this({
-      id,
-      contract,
-      runner,
-      logger,
-      traceProvider,
-      meterProvider
-    });
+    return assertEx11(this.params.runner);
   }
   async active() {
-    return await this._contract.active();
+    return await this.contract.active();
   }
   async activeByAddressStaked(address) {
-    return await this._contract.activeByAddressStaked(getAddress(address));
+    return await this.contract.activeByAddressStaked(getAddress(address));
   }
   async activeByStaker(address) {
-    return await this._contract.activeByStaker(getAddress(address));
+    return await this.contract.activeByStaker(getAddress(address));
   }
   async addStake(staked, amount) {
-    const result = await this._contract.addStake(getAddress(staked), amount);
+    const result = await this.contract.addStake(getAddress(staked), amount);
     await result.wait();
     return true;
   }
   async chainId() {
-    return toAddress(await this._contract.chainId());
+    return toAddress(await this.contract.chainId());
   }
   async forkedAtBlockNumber() {
-    return await this._contract.forkedAtBlockNumber();
+    return await this.contract.forkedAtBlockNumber();
   }
   async forkedAtHash() {
-    return await this._contract.forkedAtHash();
+    return await this.contract.forkedAtHash();
   }
   async forkedChainId() {
-    return toAddress(await this._contract.forkedChainId());
+    return toAddress(await this.contract.forkedChainId());
   }
   async minWithdrawalBlocks() {
-    return await this._contract.minWithdrawalBlocks();
+    return await this.contract.minWithdrawalBlocks();
   }
   async pending() {
-    return await this._contract.pending();
+    return await this.contract.pending();
   }
   async pendingByStaker(staker) {
-    return await this._contract.pendingByStaker(getAddress(staker));
+    return await this.contract.pendingByStaker(getAddress(staker));
   }
   async removeStake(slot) {
-    const result = await this._contract.removeStake(slot);
+    const result = await this.contract.removeStake(slot);
     await result.wait();
     return true;
   }
   async rewardsContract() {
-    return await this._contract.rewardsContract();
+    return await this.contract.rewardsContract();
   }
   async stakingTokenAddress() {
-    return await this._contract.stakingTokenAddress();
+    return await this.contract.stakingTokenAddress();
   }
   async withdrawStake(slot) {
-    const result = await this._contract.withdrawStake(slot);
+    const result = await this.contract.withdrawStake(slot);
     await result.wait();
     return true;
   }
   async withdrawn() {
-    return await this._contract.withdrawn();
+    return await this.contract.withdrawn();
   }
   async withdrawnByStaker(staker) {
-    return await this._contract.withdrawnByStaker(getAddress(staker));
-  }
-};
-
-// src/XyoChainBlockNumberIterator.ts
-import { assertEx as assertEx10 } from "@xylabs/assert";
-import { BaseEmitter as BaseEmitter2 } from "@xylabs/events";
-import { isDefined as isDefined2, isNull } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness2, asOptionalBlockBoundWitness as asOptionalBlockBoundWitness2, isBlockBoundWitness } from "@xyo-network/xl1-protocol";
-import { LRUCache as LRUCache2 } from "lru-cache";
-var XyoChainBlockNumberIterator = class _XyoChainBlockNumberIterator extends BaseEmitter2 {
-  static {
-    __name(this, "XyoChainBlockNumberIterator");
-  }
-  _blocksByBlockNumber = new LRUCache2({
-    max: 1e4
-  });
-  _chainArchivist;
-  _chainInformation;
-  _head;
-  constructor(params) {
-    super({});
-    const { chainArchivist: archivist, head } = params;
-    this._chainArchivist = archivist;
-    this._head = head;
-    this._chainInformation = {
-      id: head.chain
-    };
-  }
-  get archivist() {
-    return this._chainArchivist;
-  }
-  get chainIdentification() {
-    return this._chainInformation;
-  }
-  static async create(params) {
-    await Promise.resolve();
-    return new _XyoChainBlockNumberIterator(params);
-  }
-  async get(block) {
-    assertEx10(this._head.block >= block, () => `Block requested is newer than the current head [${block}]`);
-    const cached = this._blocksByBlockNumber.get(block);
-    if (cached) return cached;
-    const startingBlock = this._head;
-    const currentBlockHash = await PayloadBuilder6.hash(startingBlock);
-    let currentBlock = (await this._chainArchivist.get([
-      currentBlockHash
-    ])).at(0);
-    while (isDefined2(currentBlock)) {
-      assertEx10(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
-      if (isBlockBoundWitness(currentBlock)) {
-        this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
-        if (currentBlock.block === block) {
-          return currentBlock;
-        }
-        const { previous } = currentBlock;
-        if (isNull(previous)) break;
-        currentBlock = (await this._chainArchivist.get([
-          previous
-        ])).at(0);
-      }
-    }
-    throw new Error(`Block not found: ${block}`);
-  }
-  async head() {
-    return await Promise.resolve(this._head);
-  }
-  async next(block) {
-    const currentBlock = block;
-    const nextBlockNumber = currentBlock + 1;
-    return await this.get(nextBlockNumber);
-  }
-  // TODO: Decide on inclusive/exclusive (probably need inclusive to account for chain head)
-  // and then communicate via method name and documentation
-  async previous(block = void 0, count = 1) {
-    const results = [];
-    let currentBlock = isDefined2(block) ? await this.get(block) : this._head;
-    while (currentBlock && results.length < count) {
-      if (isBlockBoundWitness(currentBlock)) {
-        results.push(currentBlock);
-        const { previous } = currentBlock;
-        if (isNull(previous)) break;
-        const nextBlock = await this._chainArchivist.get([
-          previous
-        ]);
-        currentBlock = asOptionalBlockBoundWitness2(nextBlock[0]);
-      } else {
-        const hash = PayloadBuilder6.hash(currentBlock);
-        assertEx10(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
-      }
-    }
-    return results;
-  }
-  async updateHead(head) {
-    await Promise.resolve();
-    this._head = head;
-    void this.emit("headUpdated", {
-      blocks: [
-        head
-      ]
-    });
+    return await this.contract.withdrawnByStaker(getAddress(staker));
   }
 };
 export {
   BaseAccountableService,
-  BaseEthProvider,
   BaseService,
+  ChainBlockNumberIterationService,
   DEFAULT_BLOCK_SIZE,
   EvmBlockRewardService,
   EvmChainService,
@@ -1369,7 +1238,6 @@ export {
   XyoBlockProducer,
   XyoBlockRewardService,
   XyoChainAccountBalanceService,
-  XyoChainBlockNumberIterator,
   XyoElectionService,
   XyoPendingTransactionsService,
   XyoStakeIntentService,