@xyo-network/chain-services 1.16.22 → 1.16.24

package/dist/neutral/index.mjs

@@ -2,17 +2,18 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
-import { assertEx } from "@xylabs/sdk-js";
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
 import { findMostRecentBlock } from "@xyo-network/chain-protocol";
 import { StepSizes } from "@xyo-network/xl1-protocol";
 import { LruCacheMap, readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
 import { Semaphore } from "async-mutex";
 
 // src/AccountBalance/BaseAccountBalanceService.ts
-import { creatable as creatable2 } from "@xylabs/sdk-js";
+import { assertEx, creatable as creatable2 } from "@xylabs/sdk-js";
 import { spanRootAsync as spanRootAsync2 } from "@xylabs/telemetry";
 import { AttoXL1 } from "@xyo-network/xl1-protocol";
 import { balancesSummary, SimpleAccountBalanceViewer } from "@xyo-network/xl1-protocol-sdk";
+import z from "zod";
 
 // src/BaseService.ts
 import { AbstractCreatable, creatable } from "@xylabs/sdk-js";
@@ -133,24 +134,45 @@ function _ts_decorate2(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate2, "_ts_decorate");
+var BaseAccountBalanceServiceParamsZod = z.object({
+  chainArchivist: z.object().loose(),
+  chainIterator: z.object().loose(),
+  context: z.object().loose(),
+  transferContext: z.object().loose()
+});
 var BaseAccountBalanceService = class extends BaseService {
   static {
     __name(this, "BaseAccountBalanceService");
   }
   accountBalanceViewer;
   blockViewer;
+  static async paramsHandler(params) {
+    BaseAccountBalanceServiceParamsZod.parse(params);
+    assertEx(params?.context?.head, () => "BalanceStepSummaryContext is required in BaseAccountBalanceServiceParams");
+    return {
+      ...await super.paramsHandler(params),
+      ...params
+    };
+  }
   async accountBalance(address, headOrRange) {
-    const balances = await this.accountBalances([
+    const balances = await this.accountsBalances([
       address
     ], headOrRange);
     return balances[address] ?? AttoXL1(0n);
   }
-  async accountBalanceHistory(address, headOrRange) {
-    return await this.accountBalanceViewer.accountBalanceHistory(address, headOrRange);
+  accountBalanceHistory(_address, _headOrRange) {
+    throw new Error("Method not implemented.");
   }
-  async accountBalances(address, _headOrRange) {
+  async accountsBalances(address, _headOrRange) {
     return await spanRootAsync2("balances", async () => {
-      const summary = await balancesSummary(this.params.context);
+      const context = {
+        head: this.params.context.head,
+        stepSemaphores: this.params.context.stepSemaphores,
+        store: this.params.context.store,
+        chainId: this.params.context.chainId,
+        summaryMap: this.params.context.summaryMap
+      };
+      const summary = await balancesSummary(context);
       const result = {};
       for (const addr of address) {
         const summaryBalance = summary[addr] ?? 0n;
@@ -159,8 +181,8 @@ var BaseAccountBalanceService = class extends BaseService {
       return result;
     });
   }
-  async accountBalancesHistories(addresses, headOrRange) {
-    return await this.accountBalanceViewer.accountBalancesHistories(addresses, headOrRange);
+  accountsBalancesHistory(_addresses, _headOrRange) {
+    throw new Error("Method not implemented.");
   }
   createHandler() {
     this.blockViewer = blockViewerFromChainIteratorAndArchivist(this.params.chainIterator, this.params.chainArchivist);
@@ -183,8 +205,8 @@ var accountBalancesServiceFromArchivist = /* @__PURE__ */ __name(async (chainId,
   const headFunc = /* @__PURE__ */ __name(async () => {
     const head = await findMostRecentBlock(archivist);
     return [
-      assertEx(head?._hash, () => "No head found in chainArchivist"),
-      assertEx(head?.block, () => "No head found in chainArchivist")
+      assertEx2(head?._hash, () => "No head found in chainArchivist"),
+      assertEx2(head?.block, () => "No head found in chainArchivist")
     ];
   }, "headFunc");
   const service = await BaseAccountBalanceService.create({
@@ -239,15 +261,16 @@ BaseAccountTransfersService = _ts_decorate3([
 ], BaseAccountTransfersService);
 
 // src/BlockProducer/BaseBlockProducerService.ts
-import { asHash, assertEx as assertEx3, creatable as creatable4, exists, hexToBigInt, isDefined as isDefined2, toHex } from "@xylabs/sdk-js";
+import { AddressZod, asHash, assertEx as assertEx4, creatable as creatable4, exists, hexToBigInt, isDefined as isDefined2, toHex } from "@xylabs/sdk-js";
 import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
 import { buildNextBlock, createDeclarationIntent } from "@xyo-network/chain-protocol";
 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";
+import z2 from "zod";
 
 // src/BlockProducer/generateTransactionFeeTransfers.ts
 import { hexFromBigInt } from "@xylabs/sdk-js";
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
 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";
@@ -282,7 +305,7 @@ async function generateTransactionFeeTransfers(address, transactions) {
     return payload;
   });
   for (const [from, amount] of Object.entries(txGasCosts)) {
-    const fromPayload = assertEx2(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;
@@ -300,6 +323,13 @@ __name(_ts_decorate4, "_ts_decorate");
 var DEFAULT_BLOCK_SIZE = 10;
 var XYO_PRODUCER_REDECLARATION_DURATION = 1e4;
 var XYO_PRODUCER_REDECLARATION_WINDOW = 500;
+var BaseBlockProducerServiceParamsZod = z2.object({
+  balanceService: z2.object().loose(),
+  pendingTransactionsService: z2.object().loose(),
+  rejectedTransactionsArchivist: z2.object().loose(),
+  rewardAddress: AddressZod,
+  time: z2.object().loose()
+});
 var BaseBlockProducerService = class _BaseBlockProducerService extends BaseService {
   static {
     __name(this, "BaseBlockProducerService");
@@ -329,40 +359,47 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
     return this.account.address;
   }
   get account() {
-    return assertEx3(this.params.account, () => "account is required");
+    return assertEx4(this.params.account, () => "account is required");
   }
   get balanceService() {
-    return assertEx3(this.params.balanceService, () => "balanceService is required");
+    return assertEx4(this.params.balanceService, () => "balanceService is required");
   }
   get chainArchivist() {
-    return assertEx3(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx4(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainId() {
-    return assertEx3(this.params.chainId, () => "chainId is required");
+    return assertEx4(this.params.chainId, () => "chainId is required");
   }
   get electionService() {
-    return assertEx3(this.params.electionService, () => "electionService is required");
+    return assertEx4(this.params.electionService, () => "electionService is required");
   }
   get pendingTransactionsService() {
-    return assertEx3(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
+    return assertEx4(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
   }
   get rejectedTransactionsArchivist() {
-    return assertEx3(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
+    return assertEx4(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
   }
   get rewardAddress() {
-    return assertEx3(this.params.rewardAddress, () => "No reward address provided");
+    return assertEx4(this.params.rewardAddress, () => "No reward address provided");
   }
   get rewardService() {
-    return assertEx3(this.params.rewardService, () => "rewardService is required");
+    return assertEx4(this.params.rewardService, () => "rewardService is required");
   }
   get stakeIntentService() {
-    return assertEx3(this.params.stakeIntentService, () => "No StakeIntentService provided");
+    return assertEx4(this.params.stakeIntentService, () => "No StakeIntentService provided");
   }
   get time() {
-    return assertEx3(this.params.time, () => "No TimeSyncViewer provided");
+    return assertEx4(this.params.time, () => "No TimeSyncViewer provided");
   }
   get validateHydratedBlockState() {
-    return assertEx3(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
+    return assertEx4(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
+  }
+  static async paramsHandler(params) {
+    BaseBlockProducerServiceParamsZod.parse(params);
+    return {
+      ...await super.paramsHandler(params),
+      ...params
+    };
   }
   async next(head) {
     if (head.chain !== this.chainId) return;
@@ -387,7 +424,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
         }
       });
     }
-    const blockHex = assertEx3(toHex(block), () => "Failed to convert block to hex");
+    const blockHex = assertEx4(toHex(block), () => "Failed to convert block to hex");
     const blockId = new PayloadBuilder3({
       schema: BlockNumberSchema
     }).fields({
@@ -416,7 +453,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   }
   async proposeNextValidBlock(head, validateBalances = false) {
     return await this.spanAsync("proposeNextValidBlock", async () => {
-      const { block: previousBlock } = assertEx3(asBlockBoundWitness(head), () => "Invalid head block");
+      const { block: previousBlock } = assertEx4(asBlockBoundWitness(head), () => "Invalid head block");
       const nextBlock = previousBlock + 1;
       const nextBlockTransactionsStart = Date.now();
       const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, _BaseBlockProducerService.DefaultBlockSize);
@@ -441,7 +478,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
       blockPayloads.push(...fundedTransfers, timePayload);
       this.logger?.info(`Building block ${head.block + 1}`);
       const startBuild = Date.now();
-      const stepRewardPoolBalance = (await this.balanceService.accountBalances([
+      const stepRewardPoolBalance = (await this.balanceService.accountsBalances([
         XYO_STEP_REWARD_ADDRESS
       ]))[XYO_STEP_REWARD_ADDRESS];
       const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [
@@ -471,7 +508,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
       if (!transfer) return;
       const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? "00"), 0n);
       if (validateBalances) {
-        const balance = (await this.balanceService.accountBalances([
+        const balance = (await this.balanceService.accountsBalances([
           transfer.from
         ]))[transfer.from] ?? AttoXL13(0n);
         if (balance >= totalTransferCost) {
@@ -545,7 +582,7 @@ BaseBlockRewardService = _ts_decorate5([
 ], BaseBlockRewardService);
 
 // src/BlockReward/EvmBlockRewardService.ts
-import { assertEx as assertEx4, creatable as creatable6, toEthAddress } from "@xylabs/sdk-js";
+import { assertEx as assertEx5, creatable as creatable6, toEthAddress } from "@xylabs/sdk-js";
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
 function _ts_decorate6(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -560,13 +597,13 @@ var EvmBlockRewardService = class extends BaseBlockRewardService {
   }
   _contractAddress;
   get chainService() {
-    return assertEx4(this.params.chainService, () => "chainService is required");
+    return assertEx5(this.params.chainService, () => "chainService is required");
   }
   get contractAddress() {
-    return assertEx4(this._contractAddress, () => "contractAddress is required");
+    return assertEx5(this._contractAddress, () => "contractAddress is required");
   }
   get provider() {
-    return assertEx4(this.params.provider, () => "provider is required");
+    return assertEx5(this.params.provider, () => "provider is required");
   }
   async createHandler() {
     await super.createHandler();
@@ -587,7 +624,7 @@ EvmBlockRewardService = _ts_decorate6([
 ], EvmBlockRewardService);
 
 // src/BlockReward/MemoryBlockRewardService.ts
-import { assertEx as assertEx5, creatable as creatable7, toFixedPoint } from "@xylabs/sdk-js";
+import { assertEx as assertEx6, creatable as creatable7, toFixedPoint } from "@xylabs/sdk-js";
 import { rewardFromBlockNumber } from "@xyo-network/chain-protocol";
 function _ts_decorate7(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -602,22 +639,22 @@ var MemoryBlockRewardService = class extends BaseBlockRewardService {
   }
   rewardFromBlockNumber = rewardFromBlockNumber(18);
   get creatorReward() {
-    return assertEx5(this.params.creatorReward, () => "creatorReward is required");
+    return assertEx6(this.params.creatorReward, () => "creatorReward is required");
   }
   get initialReward() {
-    return assertEx5(this.params.initialStepReward, () => "initialStepReward is required");
+    return assertEx6(this.params.initialStepReward, () => "initialStepReward is required");
   }
   get minRewardPerBlock() {
-    return assertEx5(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
+    return assertEx6(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
   }
   get stepFactorDenominator() {
-    return assertEx5(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
+    return assertEx6(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
   }
   get stepFactorNumerator() {
-    return assertEx5(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
+    return assertEx6(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
   }
   get stepSize() {
-    return assertEx5(this.params.stepSize, () => "stepSize is required");
+    return assertEx6(this.params.stepSize, () => "stepSize is required");
   }
   static async paramsHandler(inParams) {
     return {
@@ -639,7 +676,7 @@ MemoryBlockRewardService = _ts_decorate7([
 ], MemoryBlockRewardService);
 
 // src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
-import { assertEx as assertEx6, isDefined as isDefined3, isNull, isUndefined } from "@xylabs/sdk-js";
+import { assertEx as assertEx7, isDefined as isDefined3, isNull, isUndefined } from "@xylabs/sdk-js";
 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";
@@ -652,21 +689,21 @@ var ChainBlockNumberIterationService = class extends BaseService {
   });
   _currentHead;
   get chainId() {
-    return assertEx6(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 assertEx6(this.params.chainMap);
+    return assertEx7(this.params.chainMap);
   }
   async get(block) {
     const head = await this.head();
-    assertEx6(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 PayloadBuilder4.hash(startingBlock);
     let currentBlock = await this.chainMap.get(currentBlockHash);
     while (isDefined3(currentBlock)) {
-      assertEx6(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 (isBlockBoundWitnessWithHashMeta(currentBlock)) {
         this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
         if (currentBlock.block === block) {
@@ -707,7 +744,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
         currentBlock = asBlockBoundWitnessWithStorageMeta2(nextBlock);
       } else {
         const hash = PayloadBuilder4.hash(currentBlock);
-        assertEx6(asBlockBoundWitnessWithStorageMeta2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
+        assertEx7(asBlockBoundWitnessWithStorageMeta2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
       }
     }
     return results;
@@ -731,7 +768,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
 };
 
 // src/ChainService/Evm/Evm.ts
-import { assertEx as assertEx7, toAddress, toEthAddress as toEthAddress2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8, toAddress, toEthAddress as toEthAddress2 } from "@xylabs/sdk-js";
 import { StakedXyoChain__factory as StakedXyoChainFactory } from "@xyo-network/typechain";
 import { getAddress } from "ethers/address";
 var EvmChainService = class extends BaseService {
@@ -739,16 +776,16 @@ var EvmChainService = class extends BaseService {
     __name(this, "EvmChainService");
   }
   get chainId() {
-    return assertEx7(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 assertEx7(this.params.contract);
+    return assertEx8(this.params.contract);
   }
   get runner() {
-    return assertEx7(this.params.runner);
+    return assertEx8(this.params.runner);
   }
   async active() {
     return await this.contract.active();
@@ -807,14 +844,15 @@ var EvmChainService = class extends BaseService {
 };
 
 // src/ChainService/Memory/Memory.ts
-import { ZERO_ADDRESS } from "@xylabs/sdk-js";
+import { assertEx as assertEx9, toAddress as toAddress2, ZERO_ADDRESS } from "@xylabs/sdk-js";
 var MemoryChainService = class extends BaseService {
   static {
     __name(this, "MemoryChainService");
   }
+  _chainId;
   _simulatedStake = 1n;
   get chainId() {
-    return ZERO_ADDRESS;
+    return assertEx9(this._chainId, () => "Chain ID not set");
   }
   async active() {
     return await Promise.resolve(this._simulatedStake);
@@ -829,7 +867,7 @@ var MemoryChainService = class extends BaseService {
     return await Promise.resolve(true);
   }
   createHandler() {
-    const { minStake } = this.params.config.producer;
+    const { minStake = 1 } = this.params.config.producer ?? {};
     this._simulatedStake = BigInt(minStake);
   }
   async forkedAtBlockNumber() {
@@ -868,10 +906,14 @@ var MemoryChainService = class extends BaseService {
   async withdrawnByStaker(_staker) {
     return await Promise.resolve(0n);
   }
+  async startHandler() {
+    await super.startHandler();
+    this._chainId = this.params.chainId ?? toAddress2(1n);
+  }
 };
 
 // src/ChainValidator/XyoValidator.ts
-import { assertEx as assertEx8, creatable as creatable8 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, creatable as creatable8 } from "@xylabs/sdk-js";
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -887,22 +929,22 @@ var XyoValidator = class extends BaseService {
     return this.account.address;
   }
   get account() {
-    return assertEx8(this.params.account, () => "account is required");
+    return assertEx10(this.params.account, () => "account is required");
   }
   get chainArchivist() {
-    return assertEx8(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx10(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainInfo() {
-    return assertEx8(this.params.chainId, () => "chainInfo is required");
+    return assertEx10(this.params.chainId, () => "chainInfo is required");
   }
   get electionService() {
-    return assertEx8(this.params.electionService, () => "electionService is required");
+    return assertEx10(this.params.electionService, () => "electionService is required");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx8(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
+    return assertEx10(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
   }
   get rewardService() {
-    return assertEx8(this.params.rewardService, () => "rewardService is required");
+    return assertEx10(this.params.rewardService, () => "rewardService is required");
   }
   validatePendingBlock(_block) {
     return [];
@@ -921,7 +963,7 @@ XyoValidator = _ts_decorate8([
 ], XyoValidator);
 
 // src/Election/BaseElectionService.ts
-import { assertEx as assertEx9, creatable as creatable9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11, creatable as creatable9 } from "@xylabs/sdk-js";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
 function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -935,13 +977,13 @@ var BaseElectionService = class extends BaseService {
     __name(this, "BaseElectionService");
   }
   get chainIterator() {
-    return assertEx9(this.params.chainIterator, () => "No chain iterator");
+    return assertEx11(this.params.chainIterator, () => "No chain iterator");
   }
   get chainStakeViewer() {
-    return assertEx9(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx11(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx9(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx11(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
@@ -1036,7 +1078,7 @@ BaseNetworkStakeStepRewardService = _ts_decorate10([
 
 // src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
-import { assertEx as assertEx10, creatable as creatable11, exists as exists2, filterAs, filterAsync, forget, isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12, creatable as creatable11, exists as exists2, filterAs, filterAsync, forget, isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
 import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
 import { asBlockBoundWitnessWithHashMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
@@ -1130,23 +1172,23 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
     return this.params.additionalPendingTransactionValidators ?? [];
   }
   get chainArchivist() {
-    return assertEx10(this.params.chainArchivist, () => "No completed blocks with data archivist");
+    return assertEx12(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get chainId() {
-    return assertEx10(this.params.chainId, () => "No chain id");
+    return assertEx12(this.params.chainId, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx10(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx12(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx10(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+    return assertEx12(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
   }
   get pendingTransactionsCount() {
     forget(this.countPendingTransactions());
     return this._pendingTransactionsCount;
   }
   get rejectedTransactionsArchivist() {
-    return assertEx10(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
+    return assertEx12(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
@@ -1201,6 +1243,13 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
             }, this.additionalPendingTransactionValidators)
           ]));
           const validTransactions = txValidationResults.filter(([, errors]) => errors.length === 0).map(([tx]) => tx);
+          const invalidTransactions = txValidationResults.filter(([, errors]) => errors.length > 0).map(([tx]) => tx);
+          if (invalidTransactions.length > 0) {
+            this.logger?.warn(`getPendingTransactions: Found ${invalidTransactions.length} invalid pending transactions`);
+            for (const tx of invalidTransactions) {
+              this.logger?.warn(tx[0]._hash);
+            }
+          }
           foundPendingTransactions.push(...validTransactions);
         }
         if (foundPendingTransactions.length > 0) {
@@ -1318,6 +1367,42 @@ BasePendingTransactionsService = _ts_decorate11([
 var isTransactionExpired = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.exp < block, "isTransactionExpired");
 var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block, "isTransactionActive");
 
+// src/Schemas/BaseSchemasService.ts
+import { creatable as creatable12 } from "@xylabs/sdk-js";
+import { spanRootAsync as spanRootAsync4 } from "@xylabs/telemetry";
+import { schemasSummary } from "@xyo-network/xl1-protocol-sdk";
+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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+var BaseSchemasService = class extends BaseService {
+  static {
+    __name(this, "BaseSchemasService");
+  }
+  async schema(head, schema) {
+    return (await this.schemas(head, [
+      schema
+    ]))[schema] ?? 0;
+  }
+  async schemas(head, schemas) {
+    return await spanRootAsync4("transfers", async () => {
+      const summary = await schemasSummary(this.params.context);
+      const result = {};
+      for (const schema of schemas) {
+        const count = summary[schema] ?? 0;
+        result[schema] = count;
+      }
+      return result;
+    });
+  }
+};
+BaseSchemasService = _ts_decorate12([
+  creatable12()
+], BaseSchemasService);
+
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
 import { exists as exists3, filterAs as filterAs2 } from "@xylabs/sdk-js";
 import { asOptionalBoundWitness } from "@xyo-network/boundwitness-model";
@@ -1345,21 +1430,21 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 }, "mapBoundWitnessToStakeIntentHashes");
 
 // src/StakeIntent/XyoStakeIntentService.ts
-import { asAddress, assertEx as assertEx11, creatable as creatable12, filterAs as filterAs3, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
+import { asAddress, assertEx as assertEx13, creatable as creatable13, filterAs as filterAs3, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
 import { analyzeChain, ChainStakeIntentAnalyzer, isChainSummaryStakeIntent } from "@xyo-network/chain-analyze";
 import { DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS, findFirstMatching, IntervalMap } from "@xyo-network/chain-utils";
 import { PayloadBuilder as 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 { asChainIndexingServiceStateWithStorageMeta, ChainIndexingServiceStateSchema, isChainIndexingServiceState, readPayloadMapFromStore as readPayloadMapFromStore2, timeBudget } 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) {
+function _ts_decorate13(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate12, "_ts_decorate");
+__name(_ts_decorate13, "_ts_decorate");
 var ACTIVE_STAKE_TTL = 1e3 * 60 * 60 * 2;
 var NO_ACTIVE_STAKE_TTL = 1e3 * 2;
 var STAKE_CACHE_MAX_ENTRIES = 1e4;
@@ -1382,16 +1467,16 @@ var XyoStakeIntentService = class extends BaseService {
   });
   _updateMutex = new Mutex3();
   get chainArchivist() {
-    return assertEx11(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx13(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainIterator() {
-    return assertEx11(this.params.chainIterator, () => "chainIterator not set");
+    return assertEx13(this.params.chainIterator, () => "chainIterator not set");
   }
   get chainStakeViewer() {
-    return assertEx11(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx13(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx11(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx13(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
     this.chainIterator.on("headUpdated", async () => {
@@ -1404,13 +1489,13 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx11(intent === "producer", () => `Support not yet added for intent ${intent}`);
+    assertEx13(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 () => {
-      assertEx11(intent === "producer", () => `Support not yet added for intent ${intent}`);
+      assertEx13(intent === "producer", () => `Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
       const candidates = [
         ...results
@@ -1475,38 +1560,40 @@ var XyoStakeIntentService = class extends BaseService {
     ]);
   }
   async recoverState(current) {
-    const currentBlock = assertEx11(asBlockBoundWitness3((await this.chainArchivist.get([
-      current
-    ]))?.[0]), () => `Block ${current} not found`);
-    const currentBlockNum = currentBlock.block;
-    const opts = {
-      ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS
-    };
-    while (true) {
-      const predicate = /* @__PURE__ */ __name((p) => {
-        const state2 = asChainIndexingServiceStateWithStorageMeta(p);
-        return state2 ? true : false;
-      }, "predicate");
-      const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts);
-      if (isChainIndexingServiceState(state)) {
-        const indexed = (await this.chainArchivist.get([
-          state.endBlockHash
-        ]))?.[0];
-        const indexedBlock = asBlockBoundWitnessWithStorageMeta3(indexed);
-        if (indexedBlock) {
-          const indexedBlockNum = indexedBlock.block;
-          if (indexedBlockNum <= currentBlockNum) {
-            const data = state.state;
-            this._producers = new IntervalMap(data);
-            this._lastIndexedBlockHash = indexedBlock._hash;
-            break;
+    return await timeBudget("XyoStakeIntentService.recoverState", console, async () => {
+      const currentBlock = assertEx13(asBlockBoundWitness3((await this.chainArchivist.get([
+        current
+      ]))?.[0]), () => `Block ${current} not found`);
+      const currentBlockNum = currentBlock.block;
+      const opts = {
+        ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS
+      };
+      while (true) {
+        const predicate = /* @__PURE__ */ __name((p) => {
+          const state2 = asChainIndexingServiceStateWithStorageMeta(p);
+          return state2 ? true : false;
+        }, "predicate");
+        const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts);
+        if (isChainIndexingServiceState(state)) {
+          const indexed = (await this.chainArchivist.get([
+            state.endBlockHash
+          ]))?.[0];
+          const indexedBlock = asBlockBoundWitnessWithStorageMeta3(indexed);
+          if (indexedBlock) {
+            const indexedBlockNum = indexedBlock.block;
+            if (indexedBlockNum <= currentBlockNum) {
+              const data = state.state;
+              this._producers = new IntervalMap(data);
+              this._lastIndexedBlockHash = indexedBlock._hash;
+              break;
+            }
           }
+        } else {
+          break;
         }
-      } else {
-        break;
+        opts.open = true;
       }
-      opts.open = true;
-    }
+    }, 2e3, true);
   }
   async updateIndex(displayProgress = false) {
     if (this._updateMutex.isLocked()) {
@@ -1516,44 +1603,46 @@ var XyoStakeIntentService = class extends BaseService {
       return await this.spanAsync("updateIndex", async () => {
         const currentHead = await this.chainIterator.head();
         if (isUndefined3(currentHead)) return;
-        const currentHeadHash = await PayloadBuilder7.hash(currentHead);
-        const chainMap = readPayloadMapFromStore2(this.chainArchivist);
-        const result = await analyzeChain({
-          chainMap
-        }, [
-          new ChainStakeIntentAnalyzer("producer")
-        ], currentHeadHash, this._lastIndexedBlockHash);
-        const signedDeclarations = filterAs3(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
-        if (currentHead.block === void 0) return;
-        const currentHeadBlockNum = currentHead.block;
-        if (displayProgress) this.logger?.log(`Updating index through 0x${currentHeadBlockNum}`);
-        for (const signedDeclaration of signedDeclarations) {
-          const { exp, nbf } = signedDeclaration;
-          const start = nbf;
-          const stop = exp;
-          const address = asAddress(signedDeclaration?.from);
-          if (start !== void 0 && stop !== void 0 && address !== void 0) {
-            this._producers.insert(address, start, stop);
+        return await timeBudget("XyoStakeIntentService.updateIndex", console, async () => {
+          const currentHeadHash = currentHead._hash;
+          const chainMap = readPayloadMapFromStore2(this.chainArchivist);
+          const result = await analyzeChain({
+            chainMap
+          }, [
+            new ChainStakeIntentAnalyzer("producer")
+          ], currentHeadHash, this._lastIndexedBlockHash);
+          const signedDeclarations = filterAs3(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
+          if (currentHead.block === void 0) return;
+          const currentHeadBlockNum = currentHead.block;
+          if (displayProgress) this.logger?.log(`Updating index through 0x${currentHeadBlockNum}`);
+          for (const signedDeclaration of signedDeclarations) {
+            const { exp, nbf } = signedDeclaration;
+            const start = nbf;
+            const stop = exp;
+            const address = asAddress(signedDeclaration?.from);
+            if (start !== void 0 && stop !== void 0 && address !== void 0) {
+              this._producers.insert(address, start, stop);
+            }
           }
-        }
-        this._lastIndexedBlockHash = currentHeadHash;
+          this._lastIndexedBlockHash = currentHeadHash;
+        }, 2e3, true);
       });
     });
   }
 };
-XyoStakeIntentService = _ts_decorate12([
-  creatable12()
+XyoStakeIntentService = _ts_decorate13([
+  creatable13()
 ], XyoStakeIntentService);
 
 // src/StepStake/BaseStepStakeService.ts
-import { creatable as creatable13 } from "@xylabs/sdk-js";
-function _ts_decorate13(decorators, target, key, desc) {
+import { creatable as creatable14 } from "@xylabs/sdk-js";
+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);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate13, "_ts_decorate");
+__name(_ts_decorate14, "_ts_decorate");
 var BaseStepStakeService = class extends BaseService {
   static {
     __name(this, "BaseStepStakeService");
@@ -1565,20 +1654,20 @@ var BaseStepStakeService = class extends BaseService {
     throw new Error("Method not implemented.");
   }
 };
-BaseStepStakeService = _ts_decorate13([
-  creatable13()
+BaseStepStakeService = _ts_decorate14([
+  creatable14()
 ], BaseStepStakeService);
 
 // src/Time/BaseTimeSyncService.ts
-import { creatable as creatable14 } from "@xylabs/sdk-js";
+import { creatable as creatable15 } from "@xylabs/sdk-js";
 import { SimpleTimeSyncViewer } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate14(decorators, target, key, desc) {
+function _ts_decorate15(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate14, "_ts_decorate");
+__name(_ts_decorate15, "_ts_decorate");
 var BaseTimeSyncService = class extends BaseService {
   static {
     __name(this, "BaseTimeSyncService");
@@ -1611,18 +1700,21 @@ var BaseTimeSyncService = class extends BaseService {
     return await this.timeSyncViewer.currentTimePayload();
   }
 };
-BaseTimeSyncService = _ts_decorate14([
-  creatable14()
+BaseTimeSyncService = _ts_decorate15([
+  creatable15()
 ], BaseTimeSyncService);
 export {
   BaseAccountBalanceService,
+  BaseAccountBalanceServiceParamsZod,
   BaseAccountTransfersService,
   BaseAccountableService,
   BaseBlockProducerService,
+  BaseBlockProducerServiceParamsZod,
   BaseBlockRewardService,
   BaseElectionService,
   BaseNetworkStakeStepRewardService,
   BasePendingTransactionsService,
+  BaseSchemasService,
   BaseService,
   BaseStepStakeService,
   BaseTimeSyncService,