@xyo-network/chain-services 1.15.18 → 1.15.20

package/dist/neutral/AccountBalance/accountBalanceServiceFromArchivist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accountBalanceServiceFromArchivist.d.ts","sourceRoot":"","sources":["../../../src/AccountBalance/accountBalanceServiceFromArchivist.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAQjF,eAAO,MAAM,mCAAmC,GAC9C,SAAS,OAAO,EAChB,WAAW,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,KACjD,OAAO,CAAC,uBAAuB,CAkBjC,CAAA"}
+{"version":3,"file":"accountBalanceServiceFromArchivist.d.ts","sourceRoot":"","sources":["../../../src/AccountBalance/accountBalanceServiceFromArchivist.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAQjF,eAAO,MAAM,mCAAmC,GAC9C,SAAS,OAAO,EAChB,WAAW,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,KACjD,OAAO,CAAC,uBAAuB,CAsBjC,CAAA"}

package/dist/neutral/AccountTransfers/accountTransfersServiceFromArchivist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accountTransfersServiceFromArchivist.d.ts","sourceRoot":"","sources":["../../../src/AccountTransfers/accountTransfersServiceFromArchivist.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAQjF,eAAO,MAAM,oCAAoC,GAC/C,SAAS,OAAO,EAChB,WAAW,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,KACjD,OAAO,CAAC,uBAAuB,CAkBjC,CAAA"}
+{"version":3,"file":"accountTransfersServiceFromArchivist.d.ts","sourceRoot":"","sources":["../../../src/AccountTransfers/accountTransfersServiceFromArchivist.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAQjF,eAAO,MAAM,oCAAoC,GAC/C,SAAS,OAAO,EAChB,WAAW,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,KACjD,OAAO,CAAC,uBAAuB,CAsBjC,CAAA"}

package/dist/neutral/index.mjs

@@ -2,8 +2,8 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
-import { ZERO_HASH } from "@xylabs/hex";
-import { LruCacheMap } from "@xyo-network/chain-protocol";
+import { assertEx } from "@xylabs/assert";
+import { findMostRecentBlock, LruCacheMap } from "@xyo-network/chain-protocol";
 import { StepSizes } from "@xyo-network/xl1-protocol";
 import { readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
 import { Semaphore } from "async-mutex";
@@ -104,6 +104,10 @@ var accountBalancesServiceFromArchivist = /* @__PURE__ */ __name(async (chainId,
     updateAgeOnGet: true
   });
   const chainMap = readPayloadMapFromStore(archivist);
+  const headFunc = /* @__PURE__ */ __name(async () => {
+    const head = await findMostRecentBlock(archivist);
+    return assertEx(head?._hash, () => "No head found in chainArchivist");
+  }, "headFunc");
   const service = await BaseAccountBalanceService.create({
     context: {
       chainId,
@@ -112,15 +116,15 @@ var accountBalancesServiceFromArchivist = /* @__PURE__ */ __name(async (chainId,
       },
       stepSemaphores: StepSizes.map(() => new Semaphore(20)),
       summaryMap,
-      head: /* @__PURE__ */ __name(() => ZERO_HASH, "head")
+      head: headFunc
     }
   });
   return service;
 }, "accountBalancesServiceFromArchivist");
 
 // src/AccountTransfers/accountTransfersServiceFromArchivist.ts
-import { ZERO_HASH as ZERO_HASH2 } from "@xylabs/hex";
-import { LruCacheMap as LruCacheMap2 } from "@xyo-network/chain-protocol";
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { findMostRecentBlock as findMostRecentBlock2, LruCacheMap as LruCacheMap2 } from "@xyo-network/chain-protocol";
 import { StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol";
 import { readPayloadMapFromStore as readPayloadMapFromStore2 } from "@xyo-network/xl1-protocol-sdk";
 import { Semaphore as Semaphore2 } from "async-mutex";
@@ -171,6 +175,10 @@ var accountTransfersServiceFromArchivist = /* @__PURE__ */ __name(async (chainId
     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");
+  }, "headFunc");
   const service = await BaseAccountTransfersService.create({
     context: {
       chainId,
@@ -179,14 +187,14 @@ var accountTransfersServiceFromArchivist = /* @__PURE__ */ __name(async (chainId
       },
       stepSemaphores: StepSizes2.map(() => new Semaphore2(20)),
       summaryMap,
-      head: /* @__PURE__ */ __name(() => ZERO_HASH2, "head")
+      head: headFunc
     }
   });
   return service;
 }, "accountTransfersServiceFromArchivist");
 
 // src/BlockProducer/BaseBlockProducerService.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
+import { assertEx as assertEx4 } from "@xylabs/assert";
 import { creatable as creatable4 } from "@xylabs/creatable";
 import { exists } from "@xylabs/exists";
 import { hexToBigInt, toHex } from "@xylabs/hex";
@@ -197,7 +205,7 @@ 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 { assertEx as assertEx3 } from "@xylabs/assert";
 import { hexFromBigInt } from "@xylabs/hex";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { TransferSchema, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-protocol";
@@ -233,7 +241,7 @@ async function generateTransactionFeeTransfers(address, transactions) {
     return payload;
   });
   for (const [from, amount] of Object.entries(txGasCosts)) {
-    const fromPayload = assertEx(payloads.find((p) => p.from === from), () => "from payload not found");
+    const fromPayload = assertEx3(payloads.find((p) => p.from === from), () => "from payload not found");
     fromPayload.transfers[address] = hexFromBigInt(amount);
   }
   return payloads;
@@ -280,40 +288,40 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
     return this.account.address;
   }
   get account() {
-    return assertEx2(this.params.account, () => "account is required");
+    return assertEx4(this.params.account, () => "account is required");
   }
   get balanceService() {
-    return assertEx2(this.params.balanceService, () => "balanceService is required");
+    return assertEx4(this.params.balanceService, () => "balanceService is required");
   }
   get chainArchivist() {
-    return assertEx2(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx4(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainId() {
-    return assertEx2(this.params.chainId, () => "chainId is required");
+    return assertEx4(this.params.chainId, () => "chainId is required");
   }
   get electionService() {
-    return assertEx2(this.params.electionService, () => "electionService is required");
+    return assertEx4(this.params.electionService, () => "electionService is required");
   }
   get pendingTransactionsService() {
-    return assertEx2(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
+    return assertEx4(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
   }
   get rejectedTransactionsArchivist() {
-    return assertEx2(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
+    return assertEx4(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
   }
   get rewardAddress() {
-    return assertEx2(this.params.rewardAddress, () => "No reward address provided");
+    return assertEx4(this.params.rewardAddress, () => "No reward address provided");
   }
   get rewardService() {
-    return assertEx2(this.params.rewardService, () => "rewardService is required");
+    return assertEx4(this.params.rewardService, () => "rewardService is required");
   }
   get stakeIntentService() {
-    return assertEx2(this.params.stakeIntentService, () => "No StakeIntentService provided");
+    return assertEx4(this.params.stakeIntentService, () => "No StakeIntentService provided");
   }
   get time() {
-    return assertEx2(this.params.time, () => "No TimeSyncViewInterface provided");
+    return assertEx4(this.params.time, () => "No TimeSyncViewInterface provided");
   }
   get validateHydratedBlockState() {
-    return assertEx2(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
+    return assertEx4(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
   }
   async next(head) {
     if (head.chain !== this.chainId) return;
@@ -333,7 +341,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
         }
       });
     }
-    const blockHex = assertEx2(toHex(block), () => "Failed to convert block to hex");
+    const blockHex = assertEx4(toHex(block), () => "Failed to convert block to hex");
     const blockId = new PayloadBuilder2({
       schema: BlockNumberSchema
     }).fields({
@@ -362,7 +370,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   }
   async proposeNextValidBlock(head, validateBalances = false) {
     return await this.spanAsync("proposeNextValidBlock", async () => {
-      const { block: previousBlock } = assertEx2(asBlockBoundWitness(head), () => "Invalid head block");
+      const { block: previousBlock } = assertEx4(asBlockBoundWitness(head), () => "Invalid head block");
       const nextBlock = previousBlock + 1;
       const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, _BaseBlockProducerService.DefaultBlockSize);
       const blockPayloads = [];
@@ -426,7 +434,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   }
   async generateTimePayload(head) {
     const [ethereum, ethHashOrNull] = await this.time.currentTimeAndHash("ethereum");
-    const ethereumHash = assertEx2(ethHashOrNull, () => "No ethereum hash available from time sync service");
+    const ethereumHash = assertEx4(ethHashOrNull, () => "No ethereum hash available from time sync service");
     const timePayload = {
       schema: TimeSchema,
       // note, this is for the previous block
@@ -481,7 +489,7 @@ BaseBlockRewardService = _ts_decorate5([
 ], BaseBlockRewardService);
 
 // src/BlockReward/EvmBlockRewardService.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
+import { assertEx as assertEx5 } from "@xylabs/assert";
 import { creatable as creatable6 } from "@xylabs/creatable";
 import { toEthAddress } from "@xylabs/hex";
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
@@ -498,13 +506,13 @@ var EvmBlockRewardService = class extends BaseBlockRewardService {
   }
   _contractAddress;
   get chainService() {
-    return assertEx3(this.params.chainService, () => "chainService is required");
+    return assertEx5(this.params.chainService, () => "chainService is required");
   }
   get contractAddress() {
-    return assertEx3(this._contractAddress, () => "contractAddress is required");
+    return assertEx5(this._contractAddress, () => "contractAddress is required");
   }
   get provider() {
-    return assertEx3(this.params.provider, () => "provider is required");
+    return assertEx5(this.params.provider, () => "provider is required");
   }
   async createHandler() {
     await super.createHandler();
@@ -525,7 +533,7 @@ EvmBlockRewardService = _ts_decorate6([
 ], EvmBlockRewardService);
 
 // src/BlockReward/MemoryBlockRewardService.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx6 } from "@xylabs/assert";
 import { creatable as creatable7 } from "@xylabs/creatable";
 import { toFixedPoint } from "@xylabs/decimal-precision";
 import { rewardFromBlockNumber } from "@xyo-network/chain-protocol";
@@ -542,22 +550,22 @@ var MemoryBlockRewardService = class extends BaseBlockRewardService {
   }
   rewardFromBlockNumber = rewardFromBlockNumber(18);
   get creatorReward() {
-    return assertEx4(this.params.creatorReward, () => "creatorReward is required");
+    return assertEx6(this.params.creatorReward, () => "creatorReward is required");
   }
   get initialReward() {
-    return assertEx4(this.params.initialStepReward, () => "initialStepReward is required");
+    return assertEx6(this.params.initialStepReward, () => "initialStepReward is required");
   }
   get minRewardPerBlock() {
-    return assertEx4(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
+    return assertEx6(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
   }
   get stepFactorDenominator() {
-    return assertEx4(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
+    return assertEx6(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
   }
   get stepFactorNumerator() {
-    return assertEx4(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
+    return assertEx6(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
   }
   get stepSize() {
-    return assertEx4(this.params.stepSize, () => "stepSize is required");
+    return assertEx6(this.params.stepSize, () => "stepSize is required");
   }
   static async paramsHandler(inParams) {
     return {
@@ -579,7 +587,7 @@ MemoryBlockRewardService = _ts_decorate7([
 ], MemoryBlockRewardService);
 
 // src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
+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, isBlockBoundWitnessWithHashStorageMeta } from "@xyo-network/xl1-protocol";
@@ -593,21 +601,21 @@ var ChainBlockNumberIterationService = class extends BaseService {
   });
   _currentHead;
   get chainId() {
-    return assertEx5(this._currentHead?.chain ?? this.params?.head?.chain, () => "Current head is not set");
+    return assertEx7(this._currentHead?.chain ?? this.params?.head?.chain, () => "Current head is not set");
   }
   get chainMap() {
-    return assertEx5(this.params.chainMap);
+    return assertEx7(this.params.chainMap);
   }
   async get(block) {
     const head = await this.head();
-    assertEx5(head.block >= block, () => `Block requested is newer than the current head [${block}]`);
+    assertEx7(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.chainMap.get(currentBlockHash);
     while (isDefined2(currentBlock)) {
-      assertEx5(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
+      assertEx7(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
       if (isBlockBoundWitnessWithHashStorageMeta(currentBlock)) {
         this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
         if (currentBlock.block === block) {
@@ -648,7 +656,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
         currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock);
       } else {
         const hash = PayloadBuilder3.hash(currentBlock);
-        assertEx5(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
+        assertEx7(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
       }
     }
     return results;
@@ -672,7 +680,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
 };
 
 // src/ChainService/Evm/Evm.ts
-import { assertEx as assertEx6 } from "@xylabs/assert";
+import { assertEx as assertEx8 } 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";
@@ -681,16 +689,16 @@ var EvmChainService = class extends BaseService {
     __name(this, "EvmChainService");
   }
   get chainId() {
-    return assertEx6(this.params.id);
+    return assertEx8(this.params.id);
   }
   get contract() {
     if (this.params.contract === void 0) {
       this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(this.chainId), this.params.runner);
     }
-    return assertEx6(this.params.contract);
+    return assertEx8(this.params.contract);
   }
   get runner() {
-    return assertEx6(this.params.runner);
+    return assertEx8(this.params.runner);
   }
   async active() {
     return await this.contract.active();
@@ -813,7 +821,7 @@ var MemoryChainService = class extends BaseService {
 };
 
 // src/ChainValidator/XyoValidator.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
+import { assertEx as assertEx9 } 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;
@@ -830,22 +838,22 @@ var XyoValidator = class extends BaseService {
     return this.account.address;
   }
   get account() {
-    return assertEx7(this.params.account, () => "account is required");
+    return assertEx9(this.params.account, () => "account is required");
   }
   get chainArchivist() {
-    return assertEx7(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx9(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainInfo() {
-    return assertEx7(this.params.chainId, () => "chainInfo is required");
+    return assertEx9(this.params.chainId, () => "chainInfo is required");
   }
   get electionService() {
-    return assertEx7(this.params.electionService, () => "electionService is required");
+    return assertEx9(this.params.electionService, () => "electionService is required");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx7(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
+    return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
   }
   get rewardService() {
-    return assertEx7(this.params.rewardService, () => "rewardService is required");
+    return assertEx9(this.params.rewardService, () => "rewardService is required");
   }
   validatePendingBlock(_block) {
     return [];
@@ -864,7 +872,7 @@ XyoValidator = _ts_decorate8([
 ], XyoValidator);
 
 // src/Election/BaseElectionService.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { creatable as creatable9 } from "@xylabs/creatable";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
 import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
@@ -880,13 +888,13 @@ var BaseElectionService = class extends BaseService {
     __name(this, "BaseElectionService");
   }
   get chainIterator() {
-    return assertEx8(this.params.chainIterator, () => "No chain iterator");
+    return assertEx10(this.params.chainIterator, () => "No chain iterator");
   }
   get chainStakeViewer() {
-    return assertEx8(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx10(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx8(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx10(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
@@ -982,13 +990,13 @@ BaseNetworkStakeStepRewardService = _ts_decorate10([
 // src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
 import { filterAs, filterAsync } from "@xylabs/array";
-import { assertEx as assertEx9 } from "@xylabs/assert";
+import { assertEx as assertEx11 } 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 { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { findMostRecentBlock } from "@xyo-network/chain-protocol";
+import { findMostRecentBlock as findMostRecentBlock3 } from "@xyo-network/chain-protocol";
 import { asBlockBoundWitnessWithHashStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 import { TransactionJsonSchemaValidator, validateTransaction } from "@xyo-network/xl1-validation";
 import { Mutex as Mutex2 } from "async-mutex";
@@ -1080,23 +1088,23 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
     return this.params.additionalPendingTransactionValidators ?? [];
   }
   get chainArchivist() {
-    return assertEx9(this.params.chainArchivist, () => "No completed blocks with data archivist");
+    return assertEx11(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get chainId() {
-    return assertEx9(this.params.chainId, () => "No chain id");
+    return assertEx11(this.params.chainId, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx11(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx9(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+    return assertEx11(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
   }
   get pendingTransactionsCount() {
     forget(this.countPendingTransactions());
     return this._pendingTransactionsCount;
   }
   get rejectedTransactionsArchivist() {
-    return assertEx9(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
+    return assertEx11(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
@@ -1165,7 +1173,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
   }
   async cleanupWorker() {
     return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-      const lastHead = await findMostRecentBlock(this.chainArchivist);
+      const lastHead = await findMostRecentBlock3(this.chainArchivist);
       if (isDefined3(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
     }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
   }
@@ -1297,7 +1305,7 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 
 // src/StakeIntent/XyoStakeIntentService.ts
 import { filterAs as filterAs3 } from "@xylabs/array";
-import { assertEx as assertEx10 } from "@xylabs/assert";
+import { assertEx as assertEx12 } from "@xylabs/assert";
 import { creatable as creatable12 } from "@xylabs/creatable";
 import { asAddress } from "@xylabs/hex";
 import { isUndefined as isUndefined3 } from "@xylabs/typeof";
@@ -1337,16 +1345,16 @@ var XyoStakeIntentService = class extends BaseService {
   });
   _updateMutex = new Mutex3();
   get chainArchivist() {
-    return assertEx10(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx12(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainIterator() {
-    return assertEx10(this.params.chainIterator, () => "chainIterator not set");
+    return assertEx12(this.params.chainIterator, () => "chainIterator not set");
   }
   get chainStakeViewer() {
-    return assertEx10(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx12(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx10(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx12(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
     this.chainIterator.on("headUpdated", async () => {
@@ -1359,13 +1367,13 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx10(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+    assertEx12(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 () => {
-      assertEx10(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+      assertEx12(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
       const candidates = [
         ...results
@@ -1430,7 +1438,7 @@ var XyoStakeIntentService = class extends BaseService {
     ]);
   }
   async recoverState(current) {
-    const currentBlock = assertEx10(asBlockBoundWitness3((await this.chainArchivist.get([
+    const currentBlock = assertEx12(asBlockBoundWitness3((await this.chainArchivist.get([
       current
     ]))?.[0]), () => `Block ${current} not found`);
     const currentBlockNum = currentBlock.block;
@@ -1525,7 +1533,7 @@ BaseStepStakeService = _ts_decorate13([
 ], BaseStepStakeService);
 
 // src/Time/BaseTimeSyncService.ts
-import { assertEx as assertEx11 } from "@xylabs/assert";
+import { assertEx as assertEx13 } from "@xylabs/assert";
 import { creatable as creatable14 } from "@xylabs/creatable";
 import { asHash } from "@xylabs/hex";
 import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
@@ -1553,7 +1561,7 @@ var BaseTimeSyncService = class extends BaseService {
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const block = assertEx11(await this.chainIterator.get(from), () => "Block not found");
+        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([
@@ -1622,10 +1630,10 @@ var BaseTimeSyncService = class extends BaseService {
         ];
       }
       case "ethereum": {
-        const provider = assertEx11(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx13(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash(assertEx11(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash(assertEx13(block?.hash, () => "Block hash not found"), true);
         return [
           blockNumber,
           blockHash