@xyo-network/chain-services 1.16.23 → 1.16.25

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";
@@ -64,67 +65,6 @@ function creatableService() {
 }
 __name(creatableService, "creatableService");
 
-// src/blockViewerFromChainIteratorAndArchivist.ts
-import { isDefined } from "@xylabs/sdk-js";
-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;
@@ -133,24 +73,48 @@ 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({
+  blockViewer: z.object().loose(),
+  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;
+  get blockViewer() {
+    return assertEx(this.params.blockViewer, () => "BlockViewer has not been initialized yet");
+  }
+  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,15 +123,15 @@ var BaseAccountBalanceService = class extends BaseService {
       return result;
     });
   }
-  accountsBalances(address, headOrRange) {
+  accountsBalancesHistory(_addresses, _headOrRange) {
     throw new Error("Method not implemented.");
   }
-  async accountsBalancesHistory(addresses, headOrRange) {
-    return await this.accountBalanceViewer.accountsBalancesHistory(addresses, headOrRange);
-  }
-  createHandler() {
-    this.blockViewer = blockViewerFromChainIteratorAndArchivist(this.params.chainIterator, this.params.chainArchivist);
-    this.accountBalanceViewer = new SimpleAccountBalanceViewer(this.params.context, this.params.transferContext, this.blockViewer);
+  async createHandler() {
+    this.accountBalanceViewer = await SimpleAccountBalanceViewer.create({
+      context: this.params.context,
+      transferContext: this.params.transferContext,
+      blockViewer: this.blockViewer
+    });
   }
 };
 BaseAccountBalanceService = _ts_decorate2([
@@ -186,8 +150,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({
@@ -242,24 +206,25 @@ 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, 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 { 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";
+import z2 from "zod";
 
 // src/BlockProducer/generateTransactionFeeTransfers.ts
 import { hexFromBigInt } from "@xylabs/sdk-js";
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { TransferSchema, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-protocol";
 import { transactionRequiredGas } from "@xyo-network/xl1-protocol-sdk";
 import { HydratedTransactionWrapper } from "@xyo-network/xl1-wrappers";
 async function generateTransactionFeeTransfers(address, transactions) {
   const txs = await Promise.all(transactions.map(async (tx) => {
     return HydratedTransactionWrapper.parse([
-      await PayloadBuilder2.addStorageMeta(tx[0]),
-      await PayloadBuilder2.addStorageMeta(tx[1])
+      await PayloadBuilder.addStorageMeta(tx[0]),
+      await PayloadBuilder.addStorageMeta(tx[1])
     ]);
   }));
   const txBaseFeeCosts = {};
@@ -285,7 +250,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;
@@ -303,6 +268,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");
@@ -332,40 +304,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;
@@ -390,8 +369,8 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
         }
       });
     }
-    const blockHex = assertEx3(toHex(block), () => "Failed to convert block to hex");
-    const blockId = new PayloadBuilder3({
+    const blockHex = assertEx4(toHex(block), () => "Failed to convert block to hex");
+    const blockId = new PayloadBuilder2({
       schema: BlockNumberSchema
     }).fields({
       block: blockHex
@@ -419,7 +398,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);
@@ -513,7 +492,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   */
   heartbeatRequired(head) {
     const epoch = head.$epoch;
-    if (isDefined2(epoch)) {
+    if (isDefined(epoch)) {
       const { heartbeatInterval } = this.params.config.producer;
       if (Date.now() - epoch > heartbeatInterval) {
         return true;
@@ -548,7 +527,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;
@@ -563,13 +542,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();
@@ -590,7 +569,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;
@@ -605,22 +584,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 {
@@ -641,10 +620,71 @@ MemoryBlockRewardService = _ts_decorate7([
   creatable7()
 ], MemoryBlockRewardService);
 
+// src/blockViewerFromChainIteratorAndArchivist.ts
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { asSignedBlockBoundWitness, asSignedBlockBoundWitnessWithStorageMeta } 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 = asSignedBlockBoundWitnessWithStorageMeta(payload);
+      if (isDefined2(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes);
+        return [
+          block,
+          payloads
+        ];
+      }
+      return null;
+    }, "blockByHash"),
+    blockByNumber: /* @__PURE__ */ __name(async function(blockNumber) {
+      const payload = asSignedBlockBoundWitness(await chainIterator.get(blockNumber));
+      const block = payload ? await PayloadBuilder3.addHashMeta(payload) : void 0;
+      if (isDefined2(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/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 { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta, isBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
 import { LRUCache } from "lru-cache";
 var ChainBlockNumberIterationService = class extends BaseService {
   static {
@@ -655,21 +695,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,10 +747,10 @@ var ChainBlockNumberIterationService = class extends BaseService {
         const { previous } = currentBlock;
         if (isNull(previous)) break;
         const nextBlock = await this.chainMap.get(previous);
-        currentBlock = asBlockBoundWitnessWithStorageMeta2(nextBlock);
+        currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock);
       } else {
         const hash = PayloadBuilder4.hash(currentBlock);
-        assertEx6(asBlockBoundWitnessWithStorageMeta2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
+        assertEx7(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
       }
     }
     return results;
@@ -727,14 +767,14 @@ var ChainBlockNumberIterationService = class extends BaseService {
   async getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head) {
     const hash = await PayloadBuilder4.hash(head);
     const stored = await this.chainMap.get(hash);
-    const newHead = asBlockBoundWitnessWithStorageMeta2(stored);
+    const newHead = asBlockBoundWitnessWithStorageMeta(stored);
     if (isUndefined(newHead)) throw new Error(`Head block not found in archivist [${hash}]`);
     return newHead;
   }
 };
 
 // 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 {
@@ -742,16 +782,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();
@@ -810,7 +850,7 @@ var EvmChainService = class extends BaseService {
 };
 
 // src/ChainService/Memory/Memory.ts
-import { assertEx as assertEx8, toAddress as toAddress2, 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");
@@ -818,7 +858,7 @@ var MemoryChainService = class extends BaseService {
   _chainId;
   _simulatedStake = 1n;
   get chainId() {
-    return assertEx8(this._chainId, () => "Chain ID not set");
+    return assertEx9(this._chainId, () => "Chain ID not set");
   }
   async active() {
     return await Promise.resolve(this._simulatedStake);
@@ -879,7 +919,7 @@ var MemoryChainService = class extends BaseService {
 };
 
 // src/ChainValidator/XyoValidator.ts
-import { assertEx as assertEx9, 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);
@@ -895,22 +935,22 @@ var XyoValidator = class extends BaseService {
     return this.account.address;
   }
   get account() {
-    return assertEx9(this.params.account, () => "account is required");
+    return assertEx10(this.params.account, () => "account is required");
   }
   get chainArchivist() {
-    return assertEx9(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx10(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainInfo() {
-    return assertEx9(this.params.chainId, () => "chainInfo is required");
+    return assertEx10(this.params.chainId, () => "chainInfo is required");
   }
   get electionService() {
-    return assertEx9(this.params.electionService, () => "electionService is required");
+    return assertEx10(this.params.electionService, () => "electionService is required");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
+    return assertEx10(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
   }
   get rewardService() {
-    return assertEx9(this.params.rewardService, () => "rewardService is required");
+    return assertEx10(this.params.rewardService, () => "rewardService is required");
   }
   validatePendingBlock(_block) {
     return [];
@@ -929,7 +969,7 @@ XyoValidator = _ts_decorate8([
 ], XyoValidator);
 
 // src/Election/BaseElectionService.ts
-import { assertEx as assertEx10, 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;
@@ -943,13 +983,13 @@ var BaseElectionService = class extends BaseService {
     __name(this, "BaseElectionService");
   }
   get chainIterator() {
-    return assertEx10(this.params.chainIterator, () => "No chain iterator");
+    return assertEx11(this.params.chainIterator, () => "No chain iterator");
   }
   get chainStakeViewer() {
-    return assertEx10(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx11(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx10(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 () => {
@@ -1044,23 +1084,23 @@ BaseNetworkStakeStepRewardService = _ts_decorate10([
 
 // src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
-import { assertEx as assertEx11, 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";
+import { asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, 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 PayloadBuilder5 } from "@xyo-network/payload-builder";
-import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { asSignedTransactionBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withStorageMeta = await PayloadBuilder5.addStorageMeta(payload.payloads);
-  const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
+  const withHashMeta = await PayloadBuilder5.addHashMeta(payload.payloads);
+  const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
       tx,
-      withStorageMeta.filter((p) => p._hash !== payload.root)
+      withHashMeta.filter((p) => p._hash !== payload.root)
     ];
   }
 }, "bundledPayloadToHydratedTransaction");
@@ -1138,23 +1178,23 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
     return this.params.additionalPendingTransactionValidators ?? [];
   }
   get chainArchivist() {
-    return assertEx11(this.params.chainArchivist, () => "No completed blocks with data archivist");
+    return assertEx12(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get chainId() {
-    return assertEx11(this.params.chainId, () => "No chain id");
+    return assertEx12(this.params.chainId, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx11(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx12(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx11(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 assertEx11(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
+    return assertEx12(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
@@ -1186,7 +1226,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
         let [lastHead] = filterAs(await this.chainArchivist.get([
           head
-        ]), asBlockBoundWitnessWithHashMeta);
+        ]), (x) => asBlockBoundWitnessWithHashMeta(x));
         if (isUndefined2(lastHead)) return [];
         await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
         const foundPendingTransactions = [];
@@ -1201,7 +1241,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           cursor = pendingBundledTransactions.at(-1)?._sequence;
           const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
           const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
-          const activeTransactions = transactions.filter(isTransactionActive(lastHead.block + 1));
+          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber(lastHead.block + 1, true)));
           const txValidationResults = await Promise.all(activeTransactions.map(async (tx) => [
             tx,
             await validateTransaction(tx, {
@@ -1292,7 +1332,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       let cursor;
       let [lastHead] = filterAs(await this.chainArchivist.get([
         head
-      ]), asBlockBoundWitnessWithHashMeta);
+      ]), (x) => asBlockBoundWitnessWithHashMeta(x));
       while (isDefined4(lastHead)) {
         const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
           limit: 100,
@@ -1307,7 +1347,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists2));
         const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
         const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
-        const expiredTransactions = transactions.filter(isTransactionExpired(lastHead.block + 1));
+        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber(lastHead.block + 1, true)));
         const expiredBundleHashes = expiredTransactions.map((expiredHydratedTx) => (
           // Find the corresponding payload bundle hash for the expired transaction
           pendingBundledTransactions.find((bundledTx) => bundledTx.root === expiredHydratedTx[0]._hash)?._hash
@@ -1371,13 +1411,13 @@ BaseSchemasService = _ts_decorate12([
 
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
 import { exists as exists3, filterAs as filterAs2 } from "@xylabs/sdk-js";
-import { asOptionalBoundWitness } from "@xyo-network/boundwitness-model";
+import { isBoundWitness } from "@xyo-network/boundwitness-model";
 import { payloadSchemasContains } from "@xyo-network/boundwitness-validator";
 import { BoundWitnessWrapper } from "@xyo-network/boundwitness-wrapper";
 import { asChainStakeIntent, ChainStakeIntentSchema } from "@xyo-network/xl1-protocol";
 var getBlockSignedStakeDeclarations = /* @__PURE__ */ __name(async (block, archivist, intent) => {
   const blockData = await archivist.get(block.payload_hashes);
-  const bwsFromBlock = filterAs2(blockData, asOptionalBoundWitness);
+  const bwsFromBlock = blockData.filter((x) => isBoundWitness(x));
   const bwsFromBlockWithDeclarations = bwsFromBlock.filter((bw) => payloadSchemasContains(bw, ChainStakeIntentSchema));
   const validBlockBwsWithDeclarations = await filterToValidSignedBoundWitnesses(bwsFromBlockWithDeclarations);
   return (await Promise.all(validBlockBwsWithDeclarations.map(async (bw) => {
@@ -1396,11 +1436,11 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 }, "mapBoundWitnessToStakeIntentHashes");
 
 // src/StakeIntent/XyoStakeIntentService.ts
-import { asAddress, assertEx as assertEx12, creatable as creatable13, 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 { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asChainStakeIntent as asChainStakeIntent2 } from "@xyo-network/xl1-protocol";
 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";
@@ -1433,16 +1473,16 @@ var XyoStakeIntentService = class extends BaseService {
   });
   _updateMutex = new Mutex3();
   get chainArchivist() {
-    return assertEx12(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx13(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainIterator() {
-    return assertEx12(this.params.chainIterator, () => "chainIterator not set");
+    return assertEx13(this.params.chainIterator, () => "chainIterator not set");
   }
   get chainStakeViewer() {
-    return assertEx12(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx13(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx12(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx13(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
     this.chainIterator.on("headUpdated", async () => {
@@ -1455,13 +1495,13 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx12(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 () => {
-      assertEx12(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
@@ -1527,7 +1567,7 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async recoverState(current) {
     return await timeBudget("XyoStakeIntentService.recoverState", console, async () => {
-      const currentBlock = assertEx12(asBlockBoundWitness3((await this.chainArchivist.get([
+      const currentBlock = assertEx13(asBlockBoundWitness3((await this.chainArchivist.get([
         current
       ]))?.[0]), () => `Block ${current} not found`);
       const currentBlockNum = currentBlock.block;
@@ -1544,7 +1584,7 @@ var XyoStakeIntentService = class extends BaseService {
           const indexed = (await this.chainArchivist.get([
             state.endBlockHash
           ]))?.[0];
-          const indexedBlock = asBlockBoundWitnessWithStorageMeta3(indexed);
+          const indexedBlock = asBlockBoundWitnessWithStorageMeta2(indexed);
           if (indexedBlock) {
             const indexedBlockNum = indexedBlock.block;
             if (indexedBlockNum <= currentBlockNum) {
@@ -1671,9 +1711,11 @@ BaseTimeSyncService = _ts_decorate15([
 ], BaseTimeSyncService);
 export {
   BaseAccountBalanceService,
+  BaseAccountBalanceServiceParamsZod,
   BaseAccountTransfersService,
   BaseAccountableService,
   BaseBlockProducerService,
+  BaseBlockProducerServiceParamsZod,
   BaseBlockRewardService,
   BaseElectionService,
   BaseNetworkStakeStepRewardService,
@@ -1693,6 +1735,7 @@ export {
   XyoStakeIntentService,
   XyoValidator,
   accountBalancesServiceFromArchivist,
+  blockViewerFromChainIteratorAndArchivist,
   creatableService,
   getBlockSignedStakeDeclarations
 };