@xyo-network/chain-services 1.15.1 → 1.15.3

package/dist/neutral/index.mjs

@@ -2,10 +2,9 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
-import { exists } from "@xylabs/exists";
-import { asHash, isHash } from "@xylabs/hex";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { LRUCache } from "lru-cache";
+import { ZERO_HASH } from "@xylabs/hex";
+import { LruCacheMap } from "@xyo-network/chain-protocol";
+import { readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
 
 // src/AccountBalance/BaseAccountBalanceService.ts
 import { creatable as creatable2 } from "@xylabs/creatable";
@@ -80,11 +79,7 @@ var BaseAccountBalanceService = class extends BaseService {
   }
   async balances(head, address) {
     return await spanRootAsync2("balances", async () => {
-      const summary = await balancesSummary({
-        chainArchivist: this.params.chainArchivist,
-        summaryRepository: this.params.summaryRepository,
-        head
-      });
+      const summary = await balancesSummary(this.params.context);
       const result = {};
       for (const addr of address) {
         const summaryBalance = summary[addr] ?? 0n;
@@ -99,46 +94,31 @@ BaseAccountBalanceService = _ts_decorate2([
 ], BaseAccountBalanceService);
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
-var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist) => {
-  const summaryArchivistCache = new LRUCache({
+var accountBalancesServiceFromArchivist = /* @__PURE__ */ __name(async (chainId, archivist) => {
+  const summaryMap = new LruCacheMap({
     max: 1e5,
     allowStale: true,
     noDisposeOnSet: false,
     updateAgeOnGet: true
   });
-  const summaryRepository = {
-    get: /* @__PURE__ */ __name((hashes) => {
-      const results = hashes.map((hash) => {
-        return summaryArchivistCache.get(hash);
-      }).filter(exists);
-      return results;
-    }, "get"),
-    insert: /* @__PURE__ */ __name(async (payloads) => {
-      const results = (await PayloadBuilder.addStorageMeta(payloads)).map((payload) => {
-        const hash = asHash(payload.hash);
-        if (isHash(hash)) {
-          summaryArchivistCache.set(hash, payload);
-          return payload;
-        }
-      }).filter(exists);
-      return results;
-    }, "insert"),
-    next: /* @__PURE__ */ __name(() => {
-      throw new Error("Not implemented");
-    }, "next")
-  };
+  const chainMap = readPayloadMapFromStore(archivist);
   const service = await BaseAccountBalanceService.create({
-    chainArchivist: archivist,
-    summaryRepository
+    context: {
+      chainId,
+      store: {
+        chainMap
+      },
+      summaryMap,
+      head: /* @__PURE__ */ __name(() => ZERO_HASH, "head")
+    }
   });
   return service;
-}, "accountBalanceServiceFromArchivist");
+}, "accountBalancesServiceFromArchivist");
 
 // src/AccountTransfers/accountTransfersServiceFromArchivist.ts
-import { exists as exists2 } from "@xylabs/exists";
-import { asHash as asHash2, isHash as isHash2 } from "@xylabs/hex";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { LRUCache as LRUCache2 } from "lru-cache";
+import { ZERO_HASH as ZERO_HASH2 } from "@xylabs/hex";
+import { LruCacheMap as LruCacheMap2 } from "@xyo-network/chain-protocol";
+import { readPayloadMapFromStore as readPayloadMapFromStore2 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/AccountTransfers/BaseAccountTransfersService.ts
 import { creatable as creatable3 } from "@xylabs/creatable";
@@ -163,13 +143,7 @@ var BaseAccountTransfersService = class extends BaseService {
   }
   async transfers(head, addresses) {
     return await spanRootAsync3("transfers", async () => {
-      const { chainArchivist, summaryRepository, account } = this.params;
-      const summary = await transfersSummary({
-        chainArchivist,
-        summaryRepository,
-        head,
-        account
-      });
+      const summary = await transfersSummary(this.params.context);
       const result = {};
       for (const addr of addresses) {
         const summaryBalance = summary[addr] ?? 0n;
@@ -184,65 +158,50 @@ BaseAccountTransfersService = _ts_decorate3([
 ], BaseAccountTransfersService);
 
 // src/AccountTransfers/accountTransfersServiceFromArchivist.ts
-var accountTransferServiceFromArchivist = /* @__PURE__ */ __name(async (archivist, account) => {
-  const summaryArchivistCache = new LRUCache2({
+var accountTransfersServiceFromArchivist = /* @__PURE__ */ __name(async (chainId, archivist) => {
+  const summaryMap = new LruCacheMap2({
     max: 1e5,
     allowStale: true,
     noDisposeOnSet: false,
     updateAgeOnGet: true
   });
-  const summaryRepository = {
-    get: /* @__PURE__ */ __name((hashes) => {
-      const results = hashes.map((hash) => {
-        return summaryArchivistCache.get(hash);
-      }).filter(exists2);
-      return results;
-    }, "get"),
-    insert: /* @__PURE__ */ __name(async (payloads) => {
-      const results = (await PayloadBuilder2.addStorageMeta(payloads)).map((payload) => {
-        const hash = asHash2(payload.hash);
-        if (isHash2(hash)) {
-          summaryArchivistCache.set(hash, payload);
-          return payload;
-        }
-      }).filter(exists2);
-      return results;
-    }, "insert"),
-    next: /* @__PURE__ */ __name(() => {
-      throw new Error("Not implemented");
-    }, "next")
-  };
+  const chainMap = readPayloadMapFromStore2(archivist);
   const service = await BaseAccountTransfersService.create({
-    chainArchivist: archivist,
-    account,
-    summaryRepository
+    context: {
+      chainId,
+      store: {
+        chainMap
+      },
+      summaryMap,
+      head: /* @__PURE__ */ __name(() => ZERO_HASH2, "head")
+    }
   });
   return service;
-}, "accountTransferServiceFromArchivist");
+}, "accountTransfersServiceFromArchivist");
 
 // src/BlockProducer/BaseBlockProducerService.ts
 import { assertEx as assertEx2 } from "@xylabs/assert";
 import { creatable as creatable4 } from "@xylabs/creatable";
-import { exists as exists3 } from "@xylabs/exists";
+import { exists } from "@xylabs/exists";
 import { hexToBigInt, toHex } from "@xylabs/hex";
 import { isDefined } from "@xylabs/typeof";
 import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
 import { buildNextBlock, createDeclarationIntent } from "@xyo-network/chain-protocol";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 import { asBlockBoundWitness, AttoXL1 as AttoXL13, BlockNumberSchema, defaultRewardRatio, TimeSchema, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
 
 // src/BlockProducer/generateTransactionFeeTransfers.ts
 import { assertEx } from "@xylabs/assert";
 import { hexFromBigInt } from "@xylabs/hex";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { TransferSchema, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-protocol";
 import { transactionRequiredGas } from "@xyo-network/xl1-protocol-sdk";
 import { HydratedTransactionWrapper } from "@xyo-network/xl1-wrappers";
 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 = {};
@@ -369,7 +328,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
       });
     }
     const blockHex = assertEx2(toHex(block), () => "Failed to convert block to hex");
-    const blockId = new PayloadBuilder4({
+    const blockId = new PayloadBuilder2({
       schema: BlockNumberSchema
     }).fields({
       block: blockHex
@@ -454,7 +413,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
         fundedTransfers.push(transfer);
         return tx;
       }
-    }))).filter(exists3);
+    }))).filter(exists);
     this.logger?.info(`Filtered ${txs.length} transactions to ${fundedTransactions.length} funded transactions in ${Date.now() - start}ms`);
     return [
       fundedTransactions,
@@ -617,22 +576,23 @@ MemoryBlockRewardService = _ts_decorate7([
 
 // src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
 import { assertEx as assertEx5 } from "@xylabs/assert";
-import { isDefined as isDefined2, isNull } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness2, isBlockBoundWitness } from "@xyo-network/xl1-protocol";
-import { LRUCache as LRUCache3 } from "lru-cache";
+import { isDefined as isDefined2, isNull, isUndefined } from "@xylabs/typeof";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta, isBlockBoundWitnessWithHashStorageMeta } from "@xyo-network/xl1-protocol";
+import { LRUCache } from "lru-cache";
 var ChainBlockNumberIterationService = class extends BaseService {
   static {
     __name(this, "ChainBlockNumberIterationService");
   }
-  _blocksByBlockNumber = new LRUCache3({
+  _blocksByBlockNumber = new LRUCache({
     max: 1e4
   });
-  get chainArchivist() {
-    return assertEx5(this.params.chainArchivist);
-  }
+  _currentHead;
   get chainId() {
-    return assertEx5(this.params.head?.chain);
+    return assertEx5(this._currentHead?.chain ?? this.params?.head?.chain, () => "Current head is not set");
+  }
+  get chainMap() {
+    return assertEx5(this.params.chainMap);
   }
   async get(block) {
     const head = await this.head();
@@ -640,28 +600,30 @@ var ChainBlockNumberIterationService = class extends BaseService {
     const cached = this._blocksByBlockNumber.get(block);
     if (cached) return cached;
     const startingBlock = head;
-    const currentBlockHash = await PayloadBuilder5.hash(startingBlock);
-    let currentBlock = (await this.chainArchivist.get([
-      currentBlockHash
-    ])).at(0);
+    const currentBlockHash = await PayloadBuilder3.hash(startingBlock);
+    let currentBlock = await this.chainMap.get(currentBlockHash);
     while (isDefined2(currentBlock)) {
       assertEx5(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
-      if (isBlockBoundWitness(currentBlock)) {
+      if (isBlockBoundWitnessWithHashStorageMeta(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);
+        currentBlock = await this.chainMap.get(previous);
       }
     }
     throw new Error(`Block not found: ${block}`);
   }
   async head() {
-    return await Promise.resolve(assertEx5(this.params.head));
+    if (isDefined2(this._currentHead)) return this._currentHead;
+    if (isDefined2(this.params.head)) {
+      const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(this.params.head);
+      this._currentHead = newHead;
+      return newHead;
+    }
+    throw new Error("Head is not set");
   }
   async next(block) {
     const currentBlock = block;
@@ -673,31 +635,36 @@ var ChainBlockNumberIterationService = class extends BaseService {
   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)) {
+    while (isDefined2(currentBlock) && results.length < count) {
+      if (isBlockBoundWitnessWithHashStorageMeta(currentBlock)) {
         results.push(currentBlock);
         const { previous } = currentBlock;
         if (isNull(previous)) break;
-        const nextBlock = await this.chainArchivist.get([
-          previous
-        ]);
-        currentBlock = asBlockBoundWitness2(nextBlock[0]);
+        const nextBlock = await this.chainMap.get(previous);
+        currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock);
       } else {
-        const hash = PayloadBuilder5.hash(currentBlock);
-        assertEx5(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
+        const hash = PayloadBuilder3.hash(currentBlock);
+        assertEx5(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
       }
     }
     return results;
   }
   async updateHead(head) {
-    await Promise.resolve();
-    this.params.head = head;
+    const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head);
+    this._currentHead = newHead;
     void this.emit("headUpdated", {
       blocks: [
-        head
+        newHead
       ]
     });
   }
+  async getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head) {
+    const hash = await PayloadBuilder3.hash(head);
+    const stored = await this.chainMap.get(hash);
+    const newHead = asBlockBoundWitnessWithStorageMeta(stored);
+    if (isUndefined(newHead)) throw new Error(`Head block not found in archivist [${hash}]`);
+    return newHead;
+  }
 };
 
 // src/ChainService/Evm/Evm.ts
@@ -896,7 +863,7 @@ XyoValidator = _ts_decorate8([
 import { assertEx as assertEx8 } from "@xylabs/assert";
 import { creatable as creatable9 } from "@xylabs/creatable";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 function _ts_decorate9(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);
@@ -921,7 +888,7 @@ var BaseElectionService = class extends BaseService {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
       const nextBlock = current.block + 1;
       const candidates = await this.stakeIntentService.getDeclaredCandidatesForBlock(nextBlock, "producer");
-      const previousBlockHash = await PayloadBuilder6.hash(current);
+      const previousBlockHash = await PayloadBuilder4.hash(current);
       return this.generateCreatorCommittee(candidates, previousBlockHash);
     });
   }
@@ -949,43 +916,46 @@ var BaseNetworkStakeStepRewardService = class extends BaseService {
   static {
     __name(this, "BaseNetworkStakeStepRewardService");
   }
-  claimedRewards(address) {
+  networkStakeStepRewardAddressHistory(_address) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepAddressReward(address, step, block) {
+  networkStakeStepRewardAddressReward(_context, _address) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepPoolRewardShares(step, block) {
+  networkStakeStepRewardAddressShare(_context, _address) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepPoolRewards(step, block) {
+  networkStakeStepRewardClaimedByAddress(_address) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepRewardAddressHistory(address) {
+  networkStakeStepRewardForStep(_context) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepRewardAddressShare(address, step, block) {
+  networkStakeStepRewardForStepForPosition(_context, _position) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepRewardForStep(step) {
+  networkStakeStepRewardPoolRewards(_context) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepRewardPositionWeight(position, step) {
+  networkStakeStepRewardPoolShares(_context) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepRewardPotentialPositionLoss(position, step) {
+  networkStakeStepRewardPositionWeight(_context, _position) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepRewardRandomizer(step, block) {
+  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepRewardStakerCount(step, block) {
+  networkStakeStepRewardRandomizer(_context) {
     throw new Error("Method not implemented.");
   }
-  networkStakeStepRewardWeightForAddress(address, step) {
+  networkStakeStepRewardStakerCount(_context) {
     throw new Error("Method not implemented.");
   }
-  unclaimedRewards(address) {
+  networkStakeStepRewardUnclaimedByAddress(_address) {
+    throw new Error("Method not implemented.");
+  }
+  networkStakeStepRewardWeightForAddress(_context, _address) {
     throw new Error("Method not implemented.");
   }
 };
@@ -998,9 +968,9 @@ import { ValueType } from "@opentelemetry/api";
 import { filterAs, filterAsync } from "@xylabs/array";
 import { assertEx as assertEx9 } from "@xylabs/assert";
 import { creatable as creatable11 } from "@xylabs/creatable";
-import { exists as exists4 } from "@xylabs/exists";
+import { exists as exists2 } from "@xylabs/exists";
 import { forget } from "@xylabs/forget";
-import { isDefined as isDefined3, isUndefined } from "@xylabs/typeof";
+import { isDefined as isDefined3, isUndefined as isUndefined2 } from "@xylabs/typeof";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
 import { findMostRecentBlock } from "@xyo-network/chain-protocol";
 import { asBlockBoundWitnessWithHashStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
@@ -1008,10 +978,10 @@ import { TransactionJsonSchemaValidator, validateTransaction } from "@xyo-networ
 import { Mutex as Mutex2 } from "async-mutex";
 
 // src/PendingTransactions/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withStorageMeta = await PayloadBuilder7.addStorageMeta(payload.payloads);
+  const withStorageMeta = await PayloadBuilder5.addStorageMeta(payload.payloads);
   const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
@@ -1022,7 +992,7 @@ var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload)
 }, "bundledPayloadToHydratedTransaction");
 
 // src/PendingTransactions/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
 import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) => {
@@ -1030,8 +1000,8 @@ var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) =>
   return bundle(root, transaction);
 }, "hydratedTransactionToPayloadBundle");
 var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder8.omitStorageMeta(p));
-  return new PayloadBuilder8({
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder6.omitStorageMeta(p));
+  return new PayloadBuilder6({
     schema: PayloadBundleSchema
   }).fields({
     payloads,
@@ -1140,7 +1110,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         let [lastHead] = filterAs(await this.chainArchivist.get([
           head
         ]), asBlockBoundWitnessWithHashStorageMeta);
-        if (isUndefined(lastHead)) return [];
+        if (isUndefined2(lastHead)) return [];
         await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
         const foundPendingTransactions = [];
         let cursor;
@@ -1153,7 +1123,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           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(exists4);
+          const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
           const activeTransactions = transactions.filter(isTransactionActive(lastHead.block + 1));
           foundPendingTransactions.push(...activeTransactions);
         }
@@ -1194,7 +1164,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
         const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map(async (tx) => {
           return await bundledPayloadToHydratedTransaction(tx);
-        }))).filter(exists4);
+        }))).filter(exists2);
         const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
           const errors = await validateTransaction(tx, this.chainId, [
             TransactionJsonSchemaValidator
@@ -1241,14 +1211,14 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         }
         cursor = pendingBundledTransactions.at(-1)?._sequence;
         const deletedTransactionBundles = pendingBundledTransactions.filter((tx) => this._removablePendingTransactionHashes.has(tx.root));
-        foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists4));
+        foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists2));
         const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-        const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists4);
+        const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
         const expiredTransactions = transactions.filter(isTransactionExpired(lastHead.block + 1));
         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(exists4);
+        )).filter(exists2);
         foundPendingTransactionsToDeleteHashes.push(...expiredBundleHashes);
       }
       const deletedHashes = await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes);
@@ -1272,7 +1242,7 @@ var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf
 
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
-import { exists as exists5 } from "@xylabs/exists";
+import { exists as exists3 } from "@xylabs/exists";
 import { asOptionalBoundWitness } from "@xyo-network/boundwitness-model";
 import { payloadSchemasContains } from "@xyo-network/boundwitness-validator";
 import { BoundWitnessWrapper } from "@xyo-network/boundwitness-wrapper";
@@ -1283,7 +1253,7 @@ var getBlockSignedStakeDeclarations = /* @__PURE__ */ __name(async (block, archi
   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(exists5);
+    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;
@@ -1302,13 +1272,14 @@ import { filterAs as filterAs3 } from "@xylabs/array";
 import { assertEx as assertEx10 } from "@xylabs/assert";
 import { creatable as creatable12 } from "@xylabs/creatable";
 import { asAddress } from "@xylabs/hex";
-import { isUndefined as isUndefined2 } from "@xylabs/typeof";
+import { isUndefined as isUndefined3 } from "@xylabs/typeof";
 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 PayloadBuilder9 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta, asChainIndexingServiceStateWithStorageMeta, asChainStakeIntent as asChainStakeIntent2, ChainIndexingServiceStateSchema, isChainIndexingServiceState } from "@xyo-network/xl1-protocol";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asChainIndexingServiceStateWithStorageMeta, asChainStakeIntent as asChainStakeIntent2, ChainIndexingServiceStateSchema, isChainIndexingServiceState } from "@xyo-network/xl1-protocol";
+import { readPayloadMapFromStore as readPayloadMapFromStore3 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex3 } from "async-mutex";
-import { LRUCache as LRUCache4 } from "lru-cache";
+import { LRUCache as LRUCache2 } from "lru-cache";
 function _ts_decorate12(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);
@@ -1333,7 +1304,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 LRUCache4({
+  _stakeCache = new LRUCache2({
     max: STAKE_CACHE_MAX_ENTRIES
   });
   _updateMutex = new Mutex3();
@@ -1354,8 +1325,8 @@ var XyoStakeIntentService = class extends BaseService {
       await this.updateIndex();
     });
     const head = await this.chainIterator.head();
-    if (isUndefined2(head)) return;
-    const headHash = await PayloadBuilder9.hash(head);
+    if (isUndefined3(head)) return;
+    const headHash = await PayloadBuilder7.hash(head);
     await this.recoverState(headHash);
   }
   async getDeclaredCandidateRanges(address, intent) {
@@ -1420,7 +1391,7 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async persistState(current) {
     const state = this._producers.serialize();
-    const payload = new PayloadBuilder9({
+    const payload = new PayloadBuilder7({
       schema: ChainIndexingServiceStateSchema
     }).fields({
       endBlockHash: current,
@@ -1448,7 +1419,7 @@ var XyoStakeIntentService = class extends BaseService {
         const indexed = (await this.chainArchivist.get([
           state.endBlockHash
         ]))?.[0];
-        const indexedBlock = asBlockBoundWitnessWithStorageMeta(indexed);
+        const indexedBlock = asBlockBoundWitnessWithStorageMeta2(indexed);
         if (indexedBlock) {
           const indexedBlockNum = indexedBlock.block;
           if (indexedBlockNum <= currentBlockNum) {
@@ -1471,9 +1442,12 @@ var XyoStakeIntentService = class extends BaseService {
     await this._updateMutex.runExclusive(async () => {
       return await this.spanAsync("updateIndex", async () => {
         const currentHead = await this.chainIterator.head();
-        if (isUndefined2(currentHead)) return;
-        const currentHeadHash = await PayloadBuilder9.hash(currentHead);
-        const result = await analyzeChain(this.chainArchivist, [
+        if (isUndefined3(currentHead)) return;
+        const currentHeadHash = await PayloadBuilder7.hash(currentHead);
+        const chainMap = readPayloadMapFromStore3(this.chainArchivist);
+        const result = await analyzeChain({
+          chainMap
+        }, [
           new ChainStakeIntentAnalyzer("producer")
         ], currentHeadHash, this._lastIndexedBlockHash);
         const signedDeclarations = filterAs3(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
@@ -1525,8 +1499,8 @@ BaseStepStakeService = _ts_decorate13([
 // src/Time/BaseTimeSyncService.ts
 import { assertEx as assertEx11 } from "@xylabs/assert";
 import { creatable as creatable14 } from "@xylabs/creatable";
-import { asHash as asHash3 } from "@xylabs/hex";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
+import { asHash } from "@xylabs/hex";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
 import { asTimePayload, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol";
 function _ts_decorate14(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1610,7 +1584,7 @@ var BaseTimeSyncService = class extends BaseService {
         const head = await this.chainIterator.head();
         return [
           head.block,
-          await PayloadBuilder10.hash(head)
+          await PayloadBuilder8.hash(head)
         ];
       }
       case "epoch": {
@@ -1623,7 +1597,7 @@ var BaseTimeSyncService = class extends BaseService {
         const provider = assertEx11(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash3(assertEx11(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash(assertEx11(block?.hash, () => "Block hash not found"), true);
         return [
           blockNumber,
           blockHash
@@ -1663,8 +1637,8 @@ export {
   XYO_PRODUCER_REDECLARATION_WINDOW,
   XyoStakeIntentService,
   XyoValidator,
-  accountBalanceServiceFromArchivist,
-  accountTransferServiceFromArchivist,
+  accountBalancesServiceFromArchivist,
+  accountTransfersServiceFromArchivist,
   creatableService,
   getBlockSignedStakeDeclarations
 };