@xyo-network/chain-services 1.16.9 → 1.16.10

package/dist/neutral/index.mjs

@@ -12,7 +12,7 @@ import { Semaphore } from "async-mutex";
 import { creatable as creatable2 } from "@xylabs/creatable";
 import { spanRootAsync as spanRootAsync2 } from "@xylabs/telemetry";
 import { AttoXL1 } from "@xyo-network/xl1-protocol";
-import { balancesSummary } from "@xyo-network/xl1-protocol-sdk";
+import { balancesSummary, SimpleAccountBalanceViewer } from "@xyo-network/xl1-protocol-sdk";
 
 // src/BaseService.ts
 import { AbstractCreatable, creatable } from "@xylabs/creatable";
@@ -64,6 +64,67 @@ function creatableService() {
 }
 __name(creatableService, "creatableService");
 
+// src/blockViewerFromChainIteratorAndArchivist.ts
+import { isDefined } from "@xylabs/typeof";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { asBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+function blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist) {
+  const result = {
+    blockByHash: /* @__PURE__ */ __name(async function(hash) {
+      const [payload] = await chainArchivist.get([
+        hash
+      ]);
+      const block = asBlockBoundWitnessWithStorageMeta(payload);
+      if (isDefined(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes);
+        return [
+          block,
+          payloads
+        ];
+      }
+      return null;
+    }, "blockByHash"),
+    blockByNumber: /* @__PURE__ */ __name(async function(blockNumber) {
+      const payload = await chainIterator.get(blockNumber);
+      const block = payload ? await PayloadBuilder.addStorageMeta(payload) : void 0;
+      if (isDefined(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes);
+        return [
+          block,
+          payloads
+        ];
+      }
+      return null;
+    }, "blockByNumber"),
+    blocksByHash: /* @__PURE__ */ __name(async function(hash, limit = 10) {
+      const results = [];
+      for (let i = 0; i < limit; i++) {
+        const block = await this.blockByHash(hash);
+        if (block) {
+          results.push(block);
+        } else {
+          break;
+        }
+      }
+      return results;
+    }, "blocksByHash"),
+    currentBlock: /* @__PURE__ */ __name(async function() {
+      const head = await chainIterator.head();
+      return this.blockByHash(head._hash);
+    }, "currentBlock"),
+    currentBlockHash: /* @__PURE__ */ __name(async function() {
+      const head = await chainIterator.head();
+      return head._hash;
+    }, "currentBlockHash"),
+    currentBlockNumber: /* @__PURE__ */ __name(async function() {
+      const head = await chainIterator.head();
+      return head.block;
+    }, "currentBlockNumber")
+  };
+  return result;
+}
+__name(blockViewerFromChainIteratorAndArchivist, "blockViewerFromChainIteratorAndArchivist");
+
 // src/AccountBalance/BaseAccountBalanceService.ts
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -76,14 +137,16 @@ var BaseAccountBalanceService = class extends BaseService {
   static {
     __name(this, "BaseAccountBalanceService");
   }
+  accountBalanceViewer;
+  blockViewer;
   async accountBalance(address, headOrRange) {
     const balances = await this.accountBalances([
       address
     ], headOrRange);
     return balances[address] ?? AttoXL1(0n);
   }
-  accountBalanceHistory(_address, _headOrRange) {
-    throw new Error("Method not implemented.");
+  async accountBalanceHistory(address, headOrRange) {
+    return await this.accountBalanceViewer.accountBalanceHistory(address, headOrRange);
   }
   async accountBalances(address, _headOrRange) {
     return await spanRootAsync2("balances", async () => {
@@ -96,8 +159,12 @@ var BaseAccountBalanceService = class extends BaseService {
       return result;
     });
   }
-  accountBalancesHistories(_address, _headOrRange) {
-    throw new Error("Method not implemented.");
+  async accountBalancesHistories(addresses, headOrRange) {
+    return await this.accountBalanceViewer.accountBalancesHistories(addresses, headOrRange);
+  }
+  createHandler() {
+    this.blockViewer = blockViewerFromChainIteratorAndArchivist(this.params.chainIterator, this.params.chainArchivist);
+    this.accountBalanceViewer = new SimpleAccountBalanceViewer(this.params.context, this.params.transferContext, this.blockViewer);
   }
 };
 BaseAccountBalanceService = _ts_decorate2([
@@ -134,13 +201,6 @@ var accountBalancesServiceFromArchivist = /* @__PURE__ */ __name(async (chainId,
   return service;
 }, "accountBalancesServiceFromArchivist");
 
-// src/AccountTransfers/accountTransfersServiceFromArchivist.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
-import { StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol";
-import { LruCacheMap as LruCacheMap2, readPayloadMapFromStore as readPayloadMapFromStore2 } from "@xyo-network/xl1-protocol-sdk";
-import { Semaphore as Semaphore2 } from "async-mutex";
-
 // src/AccountTransfers/BaseAccountTransfersService.ts
 import { creatable as creatable3 } from "@xylabs/creatable";
 import { spanRootAsync as spanRootAsync3 } from "@xylabs/telemetry";
@@ -178,59 +238,29 @@ BaseAccountTransfersService = _ts_decorate3([
   creatable3()
 ], BaseAccountTransfersService);
 
-// src/AccountTransfers/accountTransfersServiceFromArchivist.ts
-var accountTransfersServiceFromArchivist = /* @__PURE__ */ __name(async (chainId, archivist) => {
-  const summaryMap = new LruCacheMap2({
-    max: 1e5,
-    allowStale: true,
-    noDisposeOnSet: false,
-    updateAgeOnGet: true
-  });
-  const chainMap = readPayloadMapFromStore2(archivist);
-  const headFunc = /* @__PURE__ */ __name(async () => {
-    const head = await findMostRecentBlock2(archivist);
-    return [
-      assertEx2(head?._hash, () => "No head found in chainArchivist"),
-      assertEx2(head?.block, () => "No head found in chainArchivist")
-    ];
-  }, "headFunc");
-  const service = await BaseAccountTransfersService.create({
-    context: {
-      chainId,
-      store: {
-        chainMap
-      },
-      stepSemaphores: StepSizes2.map(() => new Semaphore2(20)),
-      summaryMap,
-      head: headFunc
-    }
-  });
-  return service;
-}, "accountTransfersServiceFromArchivist");
-
 // src/BlockProducer/BaseBlockProducerService.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx3 } from "@xylabs/assert";
 import { creatable as creatable4 } from "@xylabs/creatable";
 import { exists } from "@xylabs/exists";
-import { hexToBigInt, toHex } from "@xylabs/hex";
-import { isDefined } from "@xylabs/typeof";
+import { asHash, hexToBigInt, toHex } from "@xylabs/hex";
+import { isDefined as isDefined2 } from "@xylabs/typeof";
 import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
 import { buildNextBlock, createDeclarationIntent } from "@xyo-network/chain-protocol";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder3 } 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 as assertEx3 } from "@xylabs/assert";
+import { assertEx as assertEx2 } from "@xylabs/assert";
 import { hexFromBigInt } from "@xylabs/hex";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder2 } 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 PayloadBuilder.addStorageMeta(tx[0]),
-      await PayloadBuilder.addStorageMeta(tx[1])
+      await PayloadBuilder2.addStorageMeta(tx[0]),
+      await PayloadBuilder2.addStorageMeta(tx[1])
     ]);
   }));
   const txBaseFeeCosts = {};
@@ -256,7 +286,7 @@ async function generateTransactionFeeTransfers(address, transactions) {
     return payload;
   });
   for (const [from, amount] of Object.entries(txGasCosts)) {
-    const fromPayload = assertEx3(payloads.find((p) => p.from === from), () => "from payload not found");
+    const fromPayload = assertEx2(payloads.find((p) => p.from === from), () => "from payload not found");
     fromPayload.transfers[address] = hexFromBigInt(amount);
   }
   return payloads;
@@ -303,40 +333,40 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
     return this.account.address;
   }
   get account() {
-    return assertEx4(this.params.account, () => "account is required");
+    return assertEx3(this.params.account, () => "account is required");
   }
   get balanceService() {
-    return assertEx4(this.params.balanceService, () => "balanceService is required");
+    return assertEx3(this.params.balanceService, () => "balanceService is required");
   }
   get chainArchivist() {
-    return assertEx4(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx3(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainId() {
-    return assertEx4(this.params.chainId, () => "chainId is required");
+    return assertEx3(this.params.chainId, () => "chainId is required");
   }
   get electionService() {
-    return assertEx4(this.params.electionService, () => "electionService is required");
+    return assertEx3(this.params.electionService, () => "electionService is required");
   }
   get pendingTransactionsService() {
-    return assertEx4(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
+    return assertEx3(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
   }
   get rejectedTransactionsArchivist() {
-    return assertEx4(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
+    return assertEx3(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
   }
   get rewardAddress() {
-    return assertEx4(this.params.rewardAddress, () => "No reward address provided");
+    return assertEx3(this.params.rewardAddress, () => "No reward address provided");
   }
   get rewardService() {
-    return assertEx4(this.params.rewardService, () => "rewardService is required");
+    return assertEx3(this.params.rewardService, () => "rewardService is required");
   }
   get stakeIntentService() {
-    return assertEx4(this.params.stakeIntentService, () => "No StakeIntentService provided");
+    return assertEx3(this.params.stakeIntentService, () => "No StakeIntentService provided");
   }
   get time() {
-    return assertEx4(this.params.time, () => "No TimeSyncViewer provided");
+    return assertEx3(this.params.time, () => "No TimeSyncViewer provided");
   }
   get validateHydratedBlockState() {
-    return assertEx4(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
+    return assertEx3(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
   }
   async next(head) {
     if (head.chain !== this.chainId) return;
@@ -361,8 +391,8 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
         }
       });
     }
-    const blockHex = assertEx4(toHex(block), () => "Failed to convert block to hex");
-    const blockId = new PayloadBuilder2({
+    const blockHex = assertEx3(toHex(block), () => "Failed to convert block to hex");
+    const blockId = new PayloadBuilder3({
       schema: BlockNumberSchema
     }).fields({
       block: blockHex
@@ -390,7 +420,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   }
   async proposeNextValidBlock(head, validateBalances = false) {
     return await this.spanAsync("proposeNextValidBlock", async () => {
-      const { block: previousBlock } = assertEx4(asBlockBoundWitness(head), () => "Invalid head block");
+      const { block: previousBlock } = assertEx3(asBlockBoundWitness(head), () => "Invalid head block");
       const nextBlock = previousBlock + 1;
       const nextBlockTransactionsStart = Date.now();
       const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, _BaseBlockProducerService.DefaultBlockSize);
@@ -464,7 +494,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   }
   async generateTimePayload(head) {
     const [ethereum, ethHashOrNull] = await this.time.currentTimeAndHash("ethereum");
-    const ethereumHash = assertEx4(ethHashOrNull, () => "No ethereum hash available from time sync service");
+    const ethereumHash = asHash(ethHashOrNull, () => "No ethereum hash available from time sync service");
     const timePayload = {
       schema: TimeSchema,
       // note, this is for the previous block
@@ -484,7 +514,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   */
   heartbeatRequired(head) {
     const epoch = head.$epoch;
-    if (isDefined(epoch)) {
+    if (isDefined2(epoch)) {
       const { heartbeatInterval } = this.params.config.producer;
       if (Date.now() - epoch > heartbeatInterval) {
         return true;
@@ -519,7 +549,7 @@ BaseBlockRewardService = _ts_decorate5([
 ], BaseBlockRewardService);
 
 // src/BlockReward/EvmBlockRewardService.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
+import { assertEx as assertEx4 } from "@xylabs/assert";
 import { creatable as creatable6 } from "@xylabs/creatable";
 import { toEthAddress } from "@xylabs/hex";
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
@@ -536,13 +566,13 @@ var EvmBlockRewardService = class extends BaseBlockRewardService {
   }
   _contractAddress;
   get chainService() {
-    return assertEx5(this.params.chainService, () => "chainService is required");
+    return assertEx4(this.params.chainService, () => "chainService is required");
   }
   get contractAddress() {
-    return assertEx5(this._contractAddress, () => "contractAddress is required");
+    return assertEx4(this._contractAddress, () => "contractAddress is required");
   }
   get provider() {
-    return assertEx5(this.params.provider, () => "provider is required");
+    return assertEx4(this.params.provider, () => "provider is required");
   }
   async createHandler() {
     await super.createHandler();
@@ -563,7 +593,7 @@ EvmBlockRewardService = _ts_decorate6([
 ], EvmBlockRewardService);
 
 // src/BlockReward/MemoryBlockRewardService.ts
-import { assertEx as assertEx6 } from "@xylabs/assert";
+import { assertEx as assertEx5 } from "@xylabs/assert";
 import { creatable as creatable7 } from "@xylabs/creatable";
 import { toFixedPoint } from "@xylabs/decimal-precision";
 import { rewardFromBlockNumber } from "@xyo-network/chain-protocol";
@@ -580,22 +610,22 @@ var MemoryBlockRewardService = class extends BaseBlockRewardService {
   }
   rewardFromBlockNumber = rewardFromBlockNumber(18);
   get creatorReward() {
-    return assertEx6(this.params.creatorReward, () => "creatorReward is required");
+    return assertEx5(this.params.creatorReward, () => "creatorReward is required");
   }
   get initialReward() {
-    return assertEx6(this.params.initialStepReward, () => "initialStepReward is required");
+    return assertEx5(this.params.initialStepReward, () => "initialStepReward is required");
   }
   get minRewardPerBlock() {
-    return assertEx6(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
+    return assertEx5(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
   }
   get stepFactorDenominator() {
-    return assertEx6(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
+    return assertEx5(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
   }
   get stepFactorNumerator() {
-    return assertEx6(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
+    return assertEx5(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
   }
   get stepSize() {
-    return assertEx6(this.params.stepSize, () => "stepSize is required");
+    return assertEx5(this.params.stepSize, () => "stepSize is required");
   }
   static async paramsHandler(inParams) {
     return {
@@ -617,10 +647,10 @@ MemoryBlockRewardService = _ts_decorate7([
 ], MemoryBlockRewardService);
 
 // src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
-import { isDefined as isDefined2, isNull, isUndefined } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta, isBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
+import { assertEx as assertEx6 } from "@xylabs/assert";
+import { isDefined as isDefined3, isNull, isUndefined } from "@xylabs/typeof";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, isBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
 import { LRUCache } from "lru-cache";
 var ChainBlockNumberIterationService = class extends BaseService {
   static {
@@ -631,21 +661,21 @@ var ChainBlockNumberIterationService = class extends BaseService {
   });
   _currentHead;
   get chainId() {
-    return assertEx7(this._currentHead?.chain ?? this.params?.head?.chain, () => "Current head is not set");
+    return assertEx6(this._currentHead?.chain ?? this.params?.head?.chain, () => "Current head is not set");
   }
   get chainMap() {
-    return assertEx7(this.params.chainMap);
+    return assertEx6(this.params.chainMap);
   }
   async get(block) {
     const head = await this.head();
-    assertEx7(head.block >= block, () => `Block requested is newer than the current head [${block}]`);
+    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);
+    const currentBlockHash = await PayloadBuilder4.hash(startingBlock);
     let currentBlock = await this.chainMap.get(currentBlockHash);
-    while (isDefined2(currentBlock)) {
-      assertEx7(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
+    while (isDefined3(currentBlock)) {
+      assertEx6(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
       if (isBlockBoundWitnessWithHashMeta(currentBlock)) {
         this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
         if (currentBlock.block === block) {
@@ -659,8 +689,8 @@ var ChainBlockNumberIterationService = class extends BaseService {
     throw new Error(`Block not found: ${block}`);
   }
   async head() {
-    if (isDefined2(this._currentHead)) return this._currentHead;
-    if (isDefined2(this.params.head)) {
+    if (isDefined3(this._currentHead)) return this._currentHead;
+    if (isDefined3(this.params.head)) {
       const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(this.params.head);
       this._currentHead = newHead;
       return newHead;
@@ -676,17 +706,17 @@ var ChainBlockNumberIterationService = class extends BaseService {
   // 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 (isDefined2(currentBlock) && results.length < count) {
+    let currentBlock = isDefined3(block) ? await this.get(block) : await this.head();
+    while (isDefined3(currentBlock) && results.length < count) {
       if (isBlockBoundWitnessWithHashMeta(currentBlock)) {
         results.push(currentBlock);
         const { previous } = currentBlock;
         if (isNull(previous)) break;
         const nextBlock = await this.chainMap.get(previous);
-        currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock);
+        currentBlock = asBlockBoundWitnessWithStorageMeta2(nextBlock);
       } else {
-        const hash = PayloadBuilder3.hash(currentBlock);
-        assertEx7(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
+        const hash = PayloadBuilder4.hash(currentBlock);
+        assertEx6(asBlockBoundWitnessWithStorageMeta2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
       }
     }
     return results;
@@ -701,16 +731,16 @@ var ChainBlockNumberIterationService = class extends BaseService {
     });
   }
   async getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head) {
-    const hash = await PayloadBuilder3.hash(head);
+    const hash = await PayloadBuilder4.hash(head);
     const stored = await this.chainMap.get(hash);
-    const newHead = asBlockBoundWitnessWithStorageMeta(stored);
+    const newHead = asBlockBoundWitnessWithStorageMeta2(stored);
     if (isUndefined(newHead)) throw new Error(`Head block not found in archivist [${hash}]`);
     return newHead;
   }
 };
 
 // src/ChainService/Evm/Evm.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
+import { assertEx as assertEx7 } from "@xylabs/assert";
 import { toAddress, toEthAddress as toEthAddress2 } from "@xylabs/hex";
 import { StakedXyoChain__factory as StakedXyoChainFactory } from "@xyo-network/typechain";
 import { getAddress } from "ethers/address";
@@ -719,16 +749,16 @@ var EvmChainService = class extends BaseService {
     __name(this, "EvmChainService");
   }
   get chainId() {
-    return assertEx8(this.params.id);
+    return assertEx7(this.params.id);
   }
   get contract() {
     if (this.params.contract === void 0) {
       this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(this.chainId), this.params.runner);
     }
-    return assertEx8(this.params.contract);
+    return assertEx7(this.params.contract);
   }
   get runner() {
-    return assertEx8(this.params.runner);
+    return assertEx7(this.params.runner);
   }
   async active() {
     return await this.contract.active();
@@ -851,7 +881,7 @@ var MemoryChainService = class extends BaseService {
 };
 
 // src/ChainValidator/XyoValidator.ts
-import { assertEx as assertEx9 } from "@xylabs/assert";
+import { assertEx as assertEx8 } from "@xylabs/assert";
 import { creatable as creatable8 } from "@xylabs/creatable";
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -868,22 +898,22 @@ var XyoValidator = class extends BaseService {
     return this.account.address;
   }
   get account() {
-    return assertEx9(this.params.account, () => "account is required");
+    return assertEx8(this.params.account, () => "account is required");
   }
   get chainArchivist() {
-    return assertEx9(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx8(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainInfo() {
-    return assertEx9(this.params.chainId, () => "chainInfo is required");
+    return assertEx8(this.params.chainId, () => "chainInfo is required");
   }
   get electionService() {
-    return assertEx9(this.params.electionService, () => "electionService is required");
+    return assertEx8(this.params.electionService, () => "electionService is required");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
+    return assertEx8(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
   }
   get rewardService() {
-    return assertEx9(this.params.rewardService, () => "rewardService is required");
+    return assertEx8(this.params.rewardService, () => "rewardService is required");
   }
   validatePendingBlock(_block) {
     return [];
@@ -902,7 +932,7 @@ XyoValidator = _ts_decorate8([
 ], XyoValidator);
 
 // src/Election/BaseElectionService.ts
-import { assertEx as assertEx10 } from "@xylabs/assert";
+import { assertEx as assertEx9 } from "@xylabs/assert";
 import { creatable as creatable9 } from "@xylabs/creatable";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
 function _ts_decorate9(decorators, target, key, desc) {
@@ -917,13 +947,13 @@ var BaseElectionService = class extends BaseService {
     __name(this, "BaseElectionService");
   }
   get chainIterator() {
-    return assertEx10(this.params.chainIterator, () => "No chain iterator");
+    return assertEx9(this.params.chainIterator, () => "No chain iterator");
   }
   get chainStakeViewer() {
-    return assertEx10(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx9(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx10(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx9(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
@@ -1019,22 +1049,22 @@ BaseNetworkStakeStepRewardService = _ts_decorate10([
 // src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
 import { filterAs, filterAsync } from "@xylabs/array";
-import { assertEx as assertEx11 } from "@xylabs/assert";
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { creatable as creatable11 } from "@xylabs/creatable";
 import { exists as exists2 } from "@xylabs/exists";
 import { forget } from "@xylabs/forget";
-import { isDefined as isDefined3, isUndefined as isUndefined2 } from "@xylabs/typeof";
+import { isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/typeof";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { findMostRecentBlock as findMostRecentBlock3 } from "@xyo-network/chain-protocol";
+import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
 import { asBlockBoundWitnessWithHashMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 import { TransactionJsonSchemaValidator, validateTransaction } from "@xyo-network/xl1-validation";
 import { Mutex as Mutex2 } from "async-mutex";
 
 // src/PendingTransactions/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder as PayloadBuilder4 } 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 PayloadBuilder4.addStorageMeta(payload.payloads);
+  const withStorageMeta = await PayloadBuilder5.addStorageMeta(payload.payloads);
   const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
@@ -1045,7 +1075,7 @@ var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload)
 }, "bundledPayloadToHydratedTransaction");
 
 // src/PendingTransactions/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder5 } 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) => {
@@ -1053,8 +1083,8 @@ var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) =>
   return bundle(root, transaction);
 }, "hydratedTransactionToPayloadBundle");
 var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder5.omitStorageMeta(p));
-  return new PayloadBuilder5({
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder6.omitStorageMeta(p));
+  return new PayloadBuilder6({
     schema: PayloadBundleSchema
   }).fields({
     payloads,
@@ -1117,23 +1147,23 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
     return this.params.additionalPendingTransactionValidators ?? [];
   }
   get chainArchivist() {
-    return assertEx11(this.params.chainArchivist, () => "No completed blocks with data archivist");
+    return assertEx10(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get chainId() {
-    return assertEx11(this.params.chainId, () => "No chain id");
+    return assertEx10(this.params.chainId, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx11(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx10(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx11(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+    return assertEx10(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
   }
   get pendingTransactionsCount() {
     forget(this.countPendingTransactions());
     return this._pendingTransactionsCount;
   }
   get rejectedTransactionsArchivist() {
-    return assertEx11(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
+    return assertEx10(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
@@ -1202,8 +1232,8 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
   }
   async cleanupWorker() {
     return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-      const lastHead = await findMostRecentBlock3(this.chainArchivist);
-      if (isDefined3(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
+      const lastHead = await findMostRecentBlock2(this.chainArchivist);
+      if (isDefined4(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
     }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
   }
   async countPendingTransactions() {
@@ -1265,7 +1295,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       let [lastHead] = filterAs(await this.chainArchivist.get([
         head
       ]), asBlockBoundWitnessWithHashMeta);
-      while (isDefined3(lastHead)) {
+      while (isDefined4(lastHead)) {
         const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
           limit: 100,
           order: "asc",
@@ -1334,15 +1364,15 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 
 // src/StakeIntent/XyoStakeIntentService.ts
 import { filterAs as filterAs3 } from "@xylabs/array";
-import { assertEx as assertEx12 } from "@xylabs/assert";
+import { assertEx as assertEx11 } from "@xylabs/assert";
 import { creatable as creatable12 } from "@xylabs/creatable";
 import { asAddress } from "@xylabs/hex";
 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 PayloadBuilder6 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asChainStakeIntent as asChainStakeIntent2 } from "@xyo-network/xl1-protocol";
-import { asChainIndexingServiceStateWithStorageMeta, ChainIndexingServiceStateSchema, isChainIndexingServiceState, readPayloadMapFromStore as readPayloadMapFromStore3 } from "@xyo-network/xl1-protocol-sdk";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asChainStakeIntent as asChainStakeIntent2 } from "@xyo-network/xl1-protocol";
+import { asChainIndexingServiceStateWithStorageMeta, ChainIndexingServiceStateSchema, isChainIndexingServiceState, readPayloadMapFromStore as readPayloadMapFromStore2 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex3 } from "async-mutex";
 import { LRUCache as LRUCache2 } from "lru-cache";
 function _ts_decorate12(decorators, target, key, desc) {
@@ -1374,16 +1404,16 @@ var XyoStakeIntentService = class extends BaseService {
   });
   _updateMutex = new Mutex3();
   get chainArchivist() {
-    return assertEx12(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx11(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainIterator() {
-    return assertEx12(this.params.chainIterator, () => "chainIterator not set");
+    return assertEx11(this.params.chainIterator, () => "chainIterator not set");
   }
   get chainStakeViewer() {
-    return assertEx12(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx11(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx12(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx11(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
     this.chainIterator.on("headUpdated", async () => {
@@ -1391,18 +1421,18 @@ var XyoStakeIntentService = class extends BaseService {
     });
     const head = await this.chainIterator.head();
     if (isUndefined3(head)) return;
-    const headHash = await PayloadBuilder6.hash(head);
+    const headHash = await PayloadBuilder7.hash(head);
     await this.recoverState(headHash);
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx12(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+    assertEx11(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 () => {
-      assertEx12(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+      assertEx11(intent === "producer", () => `Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
       const candidates = [
         ...results
@@ -1456,7 +1486,7 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async persistState(current) {
     const state = this._producers.serialize();
-    const payload = new PayloadBuilder6({
+    const payload = new PayloadBuilder7({
       schema: ChainIndexingServiceStateSchema
     }).fields({
       endBlockHash: current,
@@ -1467,7 +1497,7 @@ var XyoStakeIntentService = class extends BaseService {
     ]);
   }
   async recoverState(current) {
-    const currentBlock = assertEx12(asBlockBoundWitness3((await this.chainArchivist.get([
+    const currentBlock = assertEx11(asBlockBoundWitness3((await this.chainArchivist.get([
       current
     ]))?.[0]), () => `Block ${current} not found`);
     const currentBlockNum = currentBlock.block;
@@ -1484,7 +1514,7 @@ var XyoStakeIntentService = class extends BaseService {
         const indexed = (await this.chainArchivist.get([
           state.endBlockHash
         ]))?.[0];
-        const indexedBlock = asBlockBoundWitnessWithStorageMeta2(indexed);
+        const indexedBlock = asBlockBoundWitnessWithStorageMeta3(indexed);
         if (indexedBlock) {
           const indexedBlockNum = indexedBlock.block;
           if (indexedBlockNum <= currentBlockNum) {
@@ -1508,8 +1538,8 @@ var XyoStakeIntentService = class extends BaseService {
       return await this.spanAsync("updateIndex", async () => {
         const currentHead = await this.chainIterator.head();
         if (isUndefined3(currentHead)) return;
-        const currentHeadHash = await PayloadBuilder6.hash(currentHead);
-        const chainMap = readPayloadMapFromStore3(this.chainArchivist);
+        const currentHeadHash = await PayloadBuilder7.hash(currentHead);
+        const chainMap = readPayloadMapFromStore2(this.chainArchivist);
         const result = await analyzeChain({
           chainMap
         }, [
@@ -1562,11 +1592,8 @@ BaseStepStakeService = _ts_decorate13([
 ], BaseStepStakeService);
 
 // src/Time/BaseTimeSyncService.ts
-import { assertEx as assertEx13 } from "@xylabs/assert";
 import { creatable as creatable14 } from "@xylabs/creatable";
-import { asHash } from "@xylabs/hex";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
-import { asTimePayload, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol";
+import { SimpleTimeSyncViewer } from "@xyo-network/xl1-protocol-sdk";
 function _ts_decorate14(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);
@@ -1578,6 +1605,7 @@ var BaseTimeSyncService = class extends BaseService {
   static {
     __name(this, "BaseTimeSyncService");
   }
+  timeSyncViewer;
   get chainArchivist() {
     return this.params.chainArchivist;
   }
@@ -1588,93 +1616,21 @@ var BaseTimeSyncService = class extends BaseService {
     return this.params.ethProvider;
   }
   async convertTime(fromDomain, toDomain, from) {
-    switch (fromDomain) {
-      case "xl1": {
-        const block = assertEx13(await this.chainIterator.get(from), () => "Block not found");
-        const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema2);
-        const hash = timeSchemaIndex === -1 ? void 0 : block.payload_hashes[timeSchemaIndex];
-        const [payload] = hash === void 0 ? [] : await this.chainArchivist.get([
-          hash
-        ]);
-        const timePayload = asTimePayload(payload);
-        if (timePayload === void 0) return 0;
-        switch (toDomain) {
-          case "xl1": {
-            return timePayload.xl1 ?? 0;
-          }
-          case "epoch": {
-            return timePayload.epoch ?? 0;
-          }
-          case "ethereum": {
-            return timePayload.ethereum ?? 0;
-          }
-          default: {
-            throw new Error(`Unsupported to toDomain: ${toDomain}`);
-          }
-        }
-      }
-      default: {
-        throw new Error(`Unsupported from fromDomain: ${fromDomain}`);
-      }
-    }
+    return await this.timeSyncViewer.convertTime(fromDomain, toDomain, from);
+  }
+  async createHandler() {
+    await super.createHandler();
+    const blockViewer = blockViewerFromChainIteratorAndArchivist(this.chainIterator, this.chainArchivist);
+    this.timeSyncViewer = new SimpleTimeSyncViewer(blockViewer, this.ethProvider);
   }
   async currentTime(domain) {
-    switch (domain) {
-      case "xl1": {
-        return [
-          "xl1",
-          (await this.chainIterator.head()).block
-        ];
-      }
-      case "epoch": {
-        return [
-          "epoch",
-          Date.now()
-        ];
-      }
-      case "ethereum": {
-        return [
-          "ethereum",
-          await this.ethProvider?.getBlockNumber() ?? 0
-        ];
-      }
-      default: {
-        throw new Error(`Unknown time domain: ${domain}`);
-      }
-    }
+    return await this.timeSyncViewer.currentTime(domain);
   }
   async currentTimeAndHash(domain) {
-    switch (domain) {
-      case "xl1": {
-        const head = await this.chainIterator.head();
-        return [
-          head.block,
-          await PayloadBuilder7.hash(head)
-        ];
-      }
-      case "epoch": {
-        return [
-          Date.now(),
-          null
-        ];
-      }
-      case "ethereum": {
-        const provider = assertEx13(this.ethProvider, () => "Ethereum provider not configured");
-        const blockNumber = await provider.getBlockNumber() ?? 0;
-        const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash(assertEx13(block?.hash, () => "Block hash not found"), true);
-        return [
-          blockNumber,
-          blockHash
-        ];
-      }
-      default: {
-        throw new Error(`Unknown time domain: ${domain}`);
-      }
-    }
+    return await this.timeSyncViewer.currentTimeAndHash(domain);
   }
-  currentTimePayload() {
-    throw new Error("Method not implemented.");
+  async currentTimePayload() {
+    return await this.timeSyncViewer.currentTimePayload();
   }
 };
 BaseTimeSyncService = _ts_decorate14([
@@ -1703,7 +1659,6 @@ export {
   XyoStakeIntentService,
   XyoValidator,
   accountBalancesServiceFromArchivist,
-  accountTransfersServiceFromArchivist,
   creatableService,
   getBlockSignedStakeDeclarations
 };