@xyo-network/chain-services 1.6.1 → 1.6.2

package/dist/neutral/index.mjs

@@ -4,13 +4,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
 import { exists } from "@xylabs/exists";
 import { asHash, isHash } from "@xylabs/hex";
-import { analyzeChain, BalanceAnalyzer, ChainSummaryBalancesSchema, isChainSummaryBalances } from "@xyo-network/chain-analyze";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { AttoXL1 as AttoXL12 } from "@xyo-network/xl1-protocol";
-import { parseSignedBigInt } from "@xyo-network/xl1-protocol-sdk";
 import { LRUCache } from "lru-cache";
 
-// src/AccountBalance/ChainAccountBalanceServiceV2.ts
+// src/AccountBalance/BaseAccountBalanceService.ts
 import { creatable as creatable2 } from "@xylabs/creatable";
 import { AttoXL1 } from "@xyo-network/xl1-protocol";
 import { balanceSummary } from "@xyo-network/xl1-protocol-sdk";
@@ -65,7 +62,7 @@ function creatableService() {
 }
 __name(creatableService, "creatableService");
 
-// src/AccountBalance/ChainAccountBalanceServiceV2.ts
+// 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;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -73,9 +70,9 @@ function _ts_decorate2(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate2, "_ts_decorate");
-var ChainAccountBalanceServiceV2 = class extends BaseService {
+var BaseAccountBalanceService = class extends BaseService {
   static {
-    __name(this, "ChainAccountBalanceServiceV2");
+    __name(this, "BaseAccountBalanceService");
   }
   async balances(head, address) {
     const summary = await balanceSummary({
@@ -90,49 +87,12 @@ var ChainAccountBalanceServiceV2 = class extends BaseService {
     return result;
   }
 };
-ChainAccountBalanceServiceV2 = _ts_decorate2([
+BaseAccountBalanceService = _ts_decorate2([
   creatable2()
-], ChainAccountBalanceServiceV2);
+], BaseAccountBalanceService);
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
-var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist, head) => {
-  let allAddressesBalances = {
-    schema: ChainSummaryBalancesSchema,
-    balances: {},
-    firstBlock: null,
-    lastBlock: null
-  };
-  const result = {
-    balances: /* @__PURE__ */ __name(async (head2, addresses) => {
-      const sync = /* @__PURE__ */ __name(async (head3) => {
-        const analysis = await analyzeChain(archivist, [
-          new BalanceAnalyzer()
-        ], head3, null, -1n);
-        allAddressesBalances = analysis.find(isChainSummaryBalances) ?? {
-          schema: ChainSummaryBalancesSchema,
-          balances: {},
-          firstBlock: null,
-          lastBlock: null
-        };
-        return await Promise.resolve();
-      }, "sync");
-      await sync(head2);
-      const result2 = {};
-      for (const addr of addresses) {
-        const signedValue = parseSignedBigInt(allAddressesBalances.balances[addr] ?? {
-          positive: "00"
-        });
-        result2[addr] = AttoXL12(signedValue > 0n ? signedValue : 0n);
-      }
-      return result2;
-    }, "balances")
-  };
-  if (isHash(head)) {
-    await result.balances(head, []);
-  }
-  return result;
-}, "accountBalanceServiceFromArchivist");
-var accountBalanceServiceFromArchivistV2 = /* @__PURE__ */ __name(async (archivist) => {
+var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist) => {
   const summaryArchivistCache = new LRUCache({
     max: 1e5,
     allowStale: true,
@@ -160,96 +120,27 @@ var accountBalanceServiceFromArchivistV2 = /* @__PURE__ */ __name(async (archivi
       throw new Error("Not implemented");
     }, "next")
   };
-  const service = await ChainAccountBalanceServiceV2.create({
+  const service = await BaseAccountBalanceService.create({
     chainArchivist: archivist,
     summaryRepository
   });
   return service;
-}, "accountBalanceServiceFromArchivistV2");
+}, "accountBalanceServiceFromArchivist");
+var accountBalanceServiceFromArchivistV2 = accountBalanceServiceFromArchivist;
 
-// src/AccountBalance/XyoChainAccountBalanceService.ts
-import { assertEx } from "@xylabs/assert";
+// src/BlockProducer/BaseBlockProducerService.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
 import { creatable as creatable3 } from "@xylabs/creatable";
-import { isDefined } from "@xylabs/typeof";
-import { analyzeChain as analyzeChain2, BalanceAnalyzer as BalanceAnalyzer2, ChainSummaryBalancesSchema as ChainSummaryBalancesSchema2, isChainSummaryBalances as isChainSummaryBalances2 } from "@xyo-network/chain-analyze";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { AttoXL1 as AttoXL13 } from "@xyo-network/xl1-protocol";
-import { parseSignedBigInt as parseSignedBigInt2 } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate3(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_decorate3, "_ts_decorate");
-var XyoChainAccountBalanceService = class extends BaseService {
-  static {
-    __name(this, "XyoChainAccountBalanceService");
-  }
-  _balances = {};
-  /**
-  * The most recent head that was indexed to
-  */
-  _firstBlock = null;
-  /**
-  * The oldest block that was indexed through
-  */
-  _lastBlock = null;
-  get chainArchivist() {
-    return assertEx(this.params.chainArchivist, () => "chainArchivist is required");
-  }
-  balances(head, address) {
-    const result = {};
-    for (const addr of address) {
-      const balance = this._balances[addr];
-      const signedBalance = balance ? parseSignedBigInt2(balance) : 0n;
-      result[addr] = AttoXL13(signedBalance >= 0n ? signedBalance : 0n);
-    }
-    return result;
-  }
-  async startHandler() {
-    if (isDefined(this.params.head)) {
-      await this.sync(this.params.head);
-    }
-  }
-  async sync(head) {
-    const startingBalances = new PayloadBuilder2({
-      schema: ChainSummaryBalancesSchema2
-    }).fields({
-      balances: this._balances,
-      firstBlock: this._firstBlock,
-      lastBlock: this._lastBlock
-    }).build();
-    const analysis = await analyzeChain2(this.chainArchivist, [
-      new BalanceAnalyzer2(void 0, void 0, startingBalances)
-    ], head, this._firstBlock);
-    const allAddressesBalances = analysis.find(isChainSummaryBalances2);
-    if (allAddressesBalances === void 0) return;
-    this._balances = {
-      ...this._balances,
-      ...allAddressesBalances.balances
-    };
-    this._firstBlock = allAddressesBalances.firstBlock;
-    if (this._lastBlock === null) this._lastBlock = allAddressesBalances.lastBlock;
-  }
-};
-XyoChainAccountBalanceService = _ts_decorate3([
-  creatable3()
-], XyoChainAccountBalanceService);
-
-// src/BlockProducer/XyoBlockProducer.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { creatable as creatable4 } from "@xylabs/creatable";
 import { exists as exists2 } from "@xylabs/exists";
 import { hexToBigInt, toHex } from "@xylabs/hex";
-import { isDefined as isDefined2 } from "@xylabs/typeof";
+import { isDefined } from "@xylabs/typeof";
 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 AttoXL14, BlockNumberSchema } from "@xyo-network/xl1-protocol";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness, AttoXL1 as AttoXL12, BlockNumberSchema } from "@xyo-network/xl1-protocol";
 
 // src/BlockProducer/generateTransactionFeeTransfers.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
+import { assertEx } from "@xylabs/assert";
 import { hexFromBigInt } from "@xylabs/hex";
 import { XYO_ZERO_ADDRESS } from "@xyo-network/chain-utils";
 import { HydratedTransactionWrapper } from "@xyo-network/chain-wrappers";
@@ -280,27 +171,27 @@ 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 = assertEx(payloads.find((p) => p.from === from), () => "from payload not found");
     fromPayload.transfers[address] = hexFromBigInt(amount);
   }
   return payloads;
 }
 __name(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
 
-// src/BlockProducer/XyoBlockProducer.ts
-function _ts_decorate4(decorators, target, key, desc) {
+// src/BlockProducer/BaseBlockProducerService.ts
+function _ts_decorate3(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_decorate4, "_ts_decorate");
+__name(_ts_decorate3, "_ts_decorate");
 var DEFAULT_BLOCK_SIZE = 10;
 var XYO_PRODUCER_REDECLARATION_DURATION = 1e4;
 var XYO_PRODUCER_REDECLARATION_WINDOW = 500;
-var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
+var BaseBlockProducerService = class _BaseBlockProducerService extends BaseService {
   static {
-    __name(this, "XyoBlockProducer");
+    __name(this, "BaseBlockProducerService");
   }
   _blockRewardDiviner;
   /**
@@ -328,43 +219,43 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
   * their intent to continue producing blocks
   */
   static get RedeclareIntent() {
-    return isDefined2(process.env.XYO_PRODUCER_SKIP_REDECLARE_INTENT) ? false : true;
+    return isDefined(process.env.XYO_PRODUCER_SKIP_REDECLARE_INTENT) ? false : true;
   }
   get address() {
     return this.account.address;
   }
   get account() {
-    return assertEx3(this.params.account, () => "account is required");
+    return assertEx2(this.params.account, () => "account is required");
   }
   get balanceService() {
-    return assertEx3(this.params.balanceService, () => "balanceService is required");
+    return assertEx2(this.params.balanceService, () => "balanceService is required");
   }
   get chainArchivist() {
-    return assertEx3(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx2(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainId() {
-    return assertEx3(this.params.chainId, () => "chainId is required");
+    return assertEx2(this.params.chainId, () => "chainId is required");
   }
   get electionService() {
-    return assertEx3(this.params.electionService, () => "electionService is required");
+    return assertEx2(this.params.electionService, () => "electionService is required");
   }
   get pendingTransactionsService() {
-    return assertEx3(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
+    return assertEx2(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
   }
   get rejectedTransactionsArchivist() {
-    return assertEx3(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
+    return assertEx2(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
   }
   get rewardAddress() {
-    return assertEx3(this.params.rewardAddress, () => "No reward address provided");
+    return assertEx2(this.params.rewardAddress, () => "No reward address provided");
   }
   get rewardService() {
-    return assertEx3(this.params.rewardService, () => "rewardService is required");
+    return assertEx2(this.params.rewardService, () => "rewardService is required");
   }
   get stakeIntentService() {
-    return assertEx3(this.params.stakeIntentService, () => "No StakeIntentService provided");
+    return assertEx2(this.params.stakeIntentService, () => "No StakeIntentService provided");
   }
   get validateHydratedBlockState() {
-    return assertEx3(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
+    return assertEx2(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
   }
   async next(head) {
     if (head.chain !== this.chainId) return;
@@ -384,8 +275,8 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
         }
       });
     }
-    const blockHex = assertEx3(toHex(block), () => "Failed to convert block to hex");
-    const blockId = new PayloadBuilder3({
+    const blockHex = assertEx2(toHex(block), () => "Failed to convert block to hex");
+    const blockId = new PayloadBuilder2({
       schema: BlockNumberSchema
     }).fields({
       block: blockHex
@@ -399,24 +290,24 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
   /**
   * Handles the producer redeclaration logic
   * @param head The current head block
-  * @returns
+  * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
   */
   async getProducerRedeclaration(head) {
-    if (!_XyoBlockProducer.RedeclareIntent) return;
+    if (!_BaseBlockProducerService.RedeclareIntent) return;
     const ranges = await this.stakeIntentService.getDeclaredCandidateRanges(this.address, "producer");
     const lastRange = ranges.toSorted((a, b) => a[1] > b[1] ? 1 : -1).at(-1);
     if (!lastRange) return;
     const [, currentDeclarationEnd] = lastRange;
     const currentBlock = head.block;
     const timeToProducerExpiration = currentDeclarationEnd - currentBlock;
-    if (timeToProducerExpiration > _XyoBlockProducer.RedeclarationWindow) return;
-    return createDeclarationIntent(this.address, "producer", currentBlock, currentBlock + _XyoBlockProducer.RedeclarationDuration);
+    if (timeToProducerExpiration > _BaseBlockProducerService.RedeclarationWindow) return;
+    return createDeclarationIntent(this.address, "producer", currentBlock, currentBlock + _BaseBlockProducerService.RedeclarationDuration);
   }
   async proposeNextValidBlock(head, validateBalances = false) {
     return await this.spanAsync("proposeNextValidBlock", async () => {
-      const { block: previousBlock } = assertEx3(asBlockBoundWitness(head), () => "Invalid head block");
+      const { block: previousBlock } = assertEx2(asBlockBoundWitness(head), () => "Invalid head block");
       const nextBlock = previousBlock + 1;
-      const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, _XyoBlockProducer.DefaultBlockSize);
+      const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, _BaseBlockProducerService.DefaultBlockSize);
       const blockPayloads = [];
       const producerRedeclarationPayload = await this.getProducerRedeclaration(head);
       if (producerRedeclarationPayload) blockPayloads.push(producerRedeclarationPayload);
@@ -432,7 +323,7 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
         if (validateBalances) {
           const balance = (await this.balanceService.balances(head._hash, [
             transfer.from
-          ]))[transfer.from] ?? AttoXL14(0n);
+          ]))[transfer.from] ?? AttoXL12(0n);
           if (balance >= totalTransferCost) {
             fundedTransfers.push(transfer);
             return tx;
@@ -460,12 +351,33 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
     });
   }
 };
-XyoBlockProducer = _ts_decorate4([
+BaseBlockProducerService = _ts_decorate3([
+  creatable3()
+], BaseBlockProducerService);
+
+// src/BlockReward/BaseBlockRewardService.ts
+import { creatable as creatable4 } from "@xylabs/creatable";
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+var BaseBlockRewardService = class extends BaseService {
+  static {
+    __name(this, "BaseBlockRewardService");
+  }
+  getRewardForBlock(_blockNumber) {
+    throw new Error("getRewardForBlock method must be implemented in derived classes");
+  }
+};
+BaseBlockRewardService = _ts_decorate4([
   creatable4()
-], XyoBlockProducer);
+], BaseBlockRewardService);
 
 // src/BlockReward/EvmBlockRewardService.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx3 } from "@xylabs/assert";
 import { creatable as creatable5 } from "@xylabs/creatable";
 import { toEthAddress } from "@xyo-network/chain-ethereum";
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
@@ -476,19 +388,19 @@ function _ts_decorate5(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate5, "_ts_decorate");
-var EvmBlockRewardService = class extends BaseService {
+var EvmBlockRewardService = class extends BaseBlockRewardService {
   static {
     __name(this, "EvmBlockRewardService");
   }
   _contractAddress;
   get chainService() {
-    return assertEx4(this.params.chainService, () => "chainService is required");
+    return assertEx3(this.params.chainService, () => "chainService is required");
   }
   get contractAddress() {
-    return assertEx4(this._contractAddress, () => "contractAddress is required");
+    return assertEx3(this._contractAddress, () => "contractAddress is required");
   }
   get provider() {
-    return assertEx4(this.params.provider, () => "provider is required");
+    return assertEx3(this.params.provider, () => "provider is required");
   }
   async createHandler() {
     await super.createHandler();
@@ -508,8 +420,8 @@ EvmBlockRewardService = _ts_decorate5([
   creatable5()
 ], EvmBlockRewardService);
 
-// src/BlockReward/XyoBlockRewardService.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
+// src/BlockReward/MemoryBlockRewardService.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
 import { creatable as creatable6 } from "@xylabs/creatable";
 import { toFixedPoint } from "@xylabs/decimal-precision";
 import { rewardFromBlockNumber } from "@xyo-network/chain-protocol";
@@ -520,28 +432,28 @@ function _ts_decorate6(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate6, "_ts_decorate");
-var XyoBlockRewardService = class extends BaseService {
+var MemoryBlockRewardService = class extends BaseBlockRewardService {
   static {
-    __name(this, "XyoBlockRewardService");
+    __name(this, "MemoryBlockRewardService");
   }
   rewardFromBlockNumber = rewardFromBlockNumber(18);
   get creatorReward() {
-    return assertEx5(this.params.creatorReward, () => "creatorReward is required");
+    return assertEx4(this.params.creatorReward, () => "creatorReward is required");
   }
   get initialReward() {
-    return assertEx5(this.params.initialStepReward, () => "initialStepReward is required");
+    return assertEx4(this.params.initialStepReward, () => "initialStepReward is required");
   }
   get minRewardPerBlock() {
-    return assertEx5(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
+    return assertEx4(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
   }
   get stepFactorDenominator() {
-    return assertEx5(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
+    return assertEx4(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
   }
   get stepFactorNumerator() {
-    return assertEx5(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
+    return assertEx4(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
   }
   get stepSize() {
-    return assertEx5(this.params.stepSize, () => "stepSize is required");
+    return assertEx4(this.params.stepSize, () => "stepSize is required");
   }
   static async paramsHandler(inParams) {
     return {
@@ -558,14 +470,14 @@ var XyoBlockRewardService = class extends BaseService {
     return this.rewardFromBlockNumber(blockNumber, this.initialReward, this.stepSize, this.stepFactorNumerator, this.stepFactorDenominator, this.minRewardPerBlock, this.creatorReward);
   }
 };
-XyoBlockRewardService = _ts_decorate6([
+MemoryBlockRewardService = _ts_decorate6([
   creatable6()
-], XyoBlockRewardService);
+], MemoryBlockRewardService);
 
 // src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
-import { assertEx as assertEx6 } from "@xylabs/assert";
-import { isDefined as isDefined3, isNull } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx5 } from "@xylabs/assert";
+import { isDefined as isDefined2, isNull } from "@xylabs/typeof";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 import { asBlockBoundWitness as asBlockBoundWitness2, isBlockBoundWitness } from "@xyo-network/xl1-protocol";
 import { LRUCache as LRUCache2 } from "lru-cache";
 var ChainBlockNumberIterationService = class extends BaseService {
@@ -576,23 +488,23 @@ var ChainBlockNumberIterationService = class extends BaseService {
     max: 1e4
   });
   get chainArchivist() {
-    return assertEx6(this.params.chainArchivist);
+    return assertEx5(this.params.chainArchivist);
   }
   get chainId() {
-    return assertEx6(this.params.head?.chain);
+    return assertEx5(this.params.head?.chain);
   }
   async get(block) {
     const head = await this.head();
-    assertEx6(head.block >= block, () => `Block requested is newer than the current head [${block}]`);
+    assertEx5(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);
+    const currentBlockHash = await PayloadBuilder3.hash(startingBlock);
     let currentBlock = (await this.chainArchivist.get([
       currentBlockHash
     ])).at(0);
-    while (isDefined3(currentBlock)) {
-      assertEx6(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
+    while (isDefined2(currentBlock)) {
+      assertEx5(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
       if (isBlockBoundWitness(currentBlock)) {
         this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
         if (currentBlock.block === block) {
@@ -608,7 +520,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
     throw new Error(`Block not found: ${block}`);
   }
   async head() {
-    return await Promise.resolve(assertEx6(this.params.head));
+    return await Promise.resolve(assertEx5(this.params.head));
   }
   async next(block) {
     const currentBlock = block;
@@ -619,7 +531,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
   // and then communicate via method name and documentation
   async previous(block = void 0, count = 1) {
     const results = [];
-    let currentBlock = isDefined3(block) ? await this.get(block) : await this.head();
+    let currentBlock = isDefined2(block) ? await this.get(block) : await this.head();
     while (currentBlock && results.length < count) {
       if (isBlockBoundWitness(currentBlock)) {
         results.push(currentBlock);
@@ -630,8 +542,8 @@ var ChainBlockNumberIterationService = class extends BaseService {
         ]);
         currentBlock = asBlockBoundWitness2(nextBlock[0]);
       } else {
-        const hash = PayloadBuilder4.hash(currentBlock);
-        assertEx6(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
+        const hash = PayloadBuilder3.hash(currentBlock);
+        assertEx5(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
       }
     }
     return results;
@@ -647,6 +559,148 @@ var ChainBlockNumberIterationService = class extends BaseService {
   }
 };
 
+// src/ChainService/Evm/Evm.ts
+import { assertEx as assertEx6 } from "@xylabs/assert";
+import { toAddress } from "@xylabs/hex";
+import { toEthAddress as toEthAddress2 } from "@xyo-network/chain-ethereum";
+import { StakedXyoChain__factory as StakedXyoChainFactory } from "@xyo-network/typechain";
+import { getAddress } from "ethers/address";
+var EvmChainService = class extends BaseService {
+  static {
+    __name(this, "EvmChainService");
+  }
+  get chainId() {
+    return assertEx6(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);
+  }
+  get runner() {
+    return assertEx6(this.params.runner);
+  }
+  async active() {
+    return await this.contract.active();
+  }
+  async activeByAddressStaked(address) {
+    return await this.contract.activeByAddressStaked(getAddress(address));
+  }
+  async activeByStaker(address) {
+    return await this.contract.activeByStaker(getAddress(address));
+  }
+  async addStake(staked, amount) {
+    const result = await this.contract.addStake(getAddress(staked), amount);
+    await result.wait();
+    return true;
+  }
+  async forkedAtBlockNumber() {
+    return await this.contract.forkedAtBlockNumber();
+  }
+  async forkedAtHash() {
+    return await this.contract.forkedAtHash();
+  }
+  async forkedChainId() {
+    return toAddress(await this.contract.forkedChainId());
+  }
+  async minWithdrawalBlocks() {
+    return await this.contract.minWithdrawalBlocks();
+  }
+  async pending() {
+    return await this.contract.pending();
+  }
+  async pendingByStaker(staker) {
+    return await this.contract.pendingByStaker(getAddress(staker));
+  }
+  async removeStake(slot) {
+    const result = await this.contract.removeStake(slot);
+    await result.wait();
+    return true;
+  }
+  async rewardsContract() {
+    return await this.contract.rewardsContract();
+  }
+  async stakingTokenAddress() {
+    return await this.contract.stakingTokenAddress();
+  }
+  async withdrawStake(slot) {
+    const result = await this.contract.withdrawStake(slot);
+    await result.wait();
+    return true;
+  }
+  async withdrawn() {
+    return await this.contract.withdrawn();
+  }
+  async withdrawnByStaker(staker) {
+    return await this.contract.withdrawnByStaker(getAddress(staker));
+  }
+};
+
+// src/ChainService/Memory/Memory.ts
+import { ZERO_ADDRESS } from "@xylabs/hex";
+import { isDefined as isDefined3 } from "@xylabs/typeof";
+var MemoryChainService = class extends BaseService {
+  static {
+    __name(this, "MemoryChainService");
+  }
+  _simulatedStake = 1n;
+  get chainId() {
+    return ZERO_ADDRESS;
+  }
+  async active() {
+    return await Promise.resolve(this._simulatedStake);
+  }
+  async activeByAddressStaked(_address) {
+    return await Promise.resolve(this._simulatedStake);
+  }
+  async activeByStaker(_address) {
+    return await Promise.resolve(this._simulatedStake);
+  }
+  async addStake(_staked, _amount) {
+    return await Promise.resolve(true);
+  }
+  createHandler() {
+    this._simulatedStake = isDefined3(process.env.XYO_PRODUCER_MIN_STAKE) ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE) : 1n;
+  }
+  async forkedAtBlockNumber() {
+    return await Promise.resolve(0n);
+  }
+  async forkedAtHash() {
+    return await Promise.resolve(0n);
+  }
+  async forkedChainId() {
+    return await Promise.resolve(ZERO_ADDRESS);
+  }
+  async minWithdrawalBlocks() {
+    return await Promise.resolve(1n);
+  }
+  async pending() {
+    return await Promise.resolve(0n);
+  }
+  async pendingByStaker(_staker) {
+    return await Promise.resolve(0n);
+  }
+  async removeStake(_slot) {
+    return await Promise.resolve(true);
+  }
+  async rewardsContract() {
+    return await Promise.resolve("");
+  }
+  async stakingTokenAddress() {
+    return await Promise.resolve("");
+  }
+  async withdrawStake(_slot) {
+    return await Promise.resolve(true);
+  }
+  async withdrawn() {
+    return await Promise.resolve(0n);
+  }
+  async withdrawnByStaker(_staker) {
+    return await Promise.resolve(0n);
+  }
+};
+
 // src/ChainValidator/XyoValidator.ts
 import { assertEx as assertEx7 } from "@xylabs/assert";
 import { creatable as creatable7 } from "@xylabs/creatable";
@@ -698,11 +752,11 @@ XyoValidator = _ts_decorate7([
   creatable7()
 ], XyoValidator);
 
-// src/Election/XyoElectionService.ts
+// src/Election/BaseElectionService.ts
 import { assertEx as assertEx8 } from "@xylabs/assert";
 import { creatable as creatable8 } from "@xylabs/creatable";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 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);
@@ -710,9 +764,9 @@ function _ts_decorate8(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate8, "_ts_decorate");
-var XyoElectionService = class extends BaseService {
+var BaseElectionService = class extends BaseService {
   static {
-    __name(this, "XyoElectionService");
+    __name(this, "BaseElectionService");
   }
   get chainIterator() {
     return assertEx8(this.params.chainIterator, () => "No chain iterator");
@@ -727,7 +781,7 @@ var XyoElectionService = class extends BaseService {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
       const nextBlock = current.block + 1;
       const candidates = await this.stakeIntentService.getDeclaredCandidatesForBlock(nextBlock, "producer");
-      const previousBlockHash = await PayloadBuilder5.hash(current);
+      const previousBlockHash = await PayloadBuilder4.hash(current);
       return this.generateCreatorCommittee(candidates, previousBlockHash);
     });
   }
@@ -738,11 +792,11 @@ var XyoElectionService = class extends BaseService {
     return creatorArray.slice(0, maxSize);
   }
 };
-XyoElectionService = _ts_decorate8([
+BaseElectionService = _ts_decorate8([
   creatable8()
-], XyoElectionService);
+], BaseElectionService);
 
-// src/PendingTransactions/PendingTransactions.ts
+// src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
 import { filterAs, filterAsync } from "@xylabs/array";
 import { assertEx as assertEx9 } from "@xylabs/assert";
@@ -758,10 +812,10 @@ import { asBlockBoundWitnessWithHashStorageMeta, isTransactionBoundWitnessWithSt
 import { Mutex as Mutex2 } from "async-mutex";
 
 // src/PendingTransactions/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withStorageMeta = await PayloadBuilder6.addStorageMeta(payload.payloads);
+  const withStorageMeta = await PayloadBuilder5.addStorageMeta(payload.payloads);
   const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
@@ -772,7 +826,7 @@ var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload)
 }, "bundledPayloadToHydratedTransaction");
 
 // src/PendingTransactions/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
 import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) => {
@@ -780,8 +834,8 @@ var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) =>
   return bundle(root, transaction);
 }, "hydratedTransactionToPayloadBundle");
 var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder7.omitStorageMeta(p));
-  return new PayloadBuilder7({
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder6.omitStorageMeta(p));
+  return new PayloadBuilder6({
     schema: PayloadBundleSchema
   }).fields({
     payloads,
@@ -789,7 +843,7 @@ var bundle = /* @__PURE__ */ __name((root, transaction) => {
   }).build();
 }, "bundle");
 
-// src/PendingTransactions/PendingTransactions.ts
+// src/PendingTransactions/BasePendingTransactions.ts
 function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -797,10 +851,10 @@ function _ts_decorate9(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate9, "_ts_decorate");
-globalAttributes.setAttribute("XyoPendingTransactionsService:status", "unknown");
-var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends BaseService {
+globalAttributes.setAttribute("BasePendingTransactionsService:status", "unknown");
+var BasePendingTransactionsService = class _BasePendingTransactionsService extends BaseService {
   static {
-    __name(this, "XyoPendingTransactionsService");
+    __name(this, "BasePendingTransactionsService");
   }
   static MutexPriority = {
     /**
@@ -884,7 +938,7 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
     pendingTransactionsCounter?.addCallback((observer) => {
       observer.observe(this.pendingTransactionsCount);
     });
-    globalAttributes.setAttribute("XyoPendingTransactionsService:status", "created");
+    globalAttributes.setAttribute("BasePendingTransactionsService:status", "created");
   }
   async getPendingTransactions(head, limit) {
     return await this.spanAsync("getPendingTransactions", async () => {
@@ -916,14 +970,14 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
           }
         }
         return foundPendingTransactions;
-      }, _XyoPendingTransactionsService.MutexPriority.ReadTransactions);
+      }, _BasePendingTransactionsService.MutexPriority.ReadTransactions);
     });
   }
   async cleanupWorker() {
     return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
       const lastHead = await findMostRecentBlock(this.chainArchivist);
       if (isDefined4(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
-    }, _XyoPendingTransactionsService.MutexPriority.PurgeTransactions);
+    }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
   }
   async countPendingTransactions() {
     if (this._countPendingTransactionsMutex.isLocked()) return;
@@ -958,7 +1012,7 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
           const bundledTransactions = validTransactions.map((tx) => hydratedTransactionToPayloadBundle(tx));
           await this.pendingBundledTransactionsLocalArchivist.insert(bundledTransactions);
         }
-      }, _XyoPendingTransactionsService.MutexPriority.InsertNewTransactions);
+      }, _BasePendingTransactionsService.MutexPriority.InsertNewTransactions);
     });
   }
   /**
@@ -1014,9 +1068,9 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
     });
   }
 };
-XyoPendingTransactionsService = _ts_decorate9([
+BasePendingTransactionsService = _ts_decorate9([
   creatable9()
-], XyoPendingTransactionsService);
+], BasePendingTransactionsService);
 var isTransactionExpired = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.exp < block, "isTransactionExpired");
 var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block, "isTransactionActive");
 
@@ -1053,9 +1107,9 @@ import { assertEx as assertEx10 } from "@xylabs/assert";
 import { creatable as creatable10 } from "@xylabs/creatable";
 import { asAddress } from "@xylabs/hex";
 import { isDefined as isDefined5, isUndefined as isUndefined2 } from "@xylabs/typeof";
-import { analyzeChain as analyzeChain3, ChainStakeIntentAnalyzer, isChainSummaryStakeIntent } from "@xyo-network/chain-analyze";
+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 PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta, asChainIndexingServiceStateWithStorageMeta, asChainStakeIntent as asChainStakeIntent2, ChainIndexingServiceStateSchema, isChainIndexingServiceState } from "@xyo-network/xl1-protocol";
 import { Mutex as Mutex3 } from "async-mutex";
 import { LRUCache as LRUCache3 } from "lru-cache";
@@ -1105,7 +1159,7 @@ var XyoStakeIntentService = class extends BaseService {
     });
     const head = await this.chainIterator.head();
     if (isUndefined2(head)) return;
-    const headHash = await PayloadBuilder8.hash(head);
+    const headHash = await PayloadBuilder7.hash(head);
     await this.recoverState(headHash);
   }
   async getDeclaredCandidateRanges(address, intent) {
@@ -1170,7 +1224,7 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async persistState(current) {
     const state = this._producers.serialize();
-    const payload = new PayloadBuilder8({
+    const payload = new PayloadBuilder7({
       schema: ChainIndexingServiceStateSchema
     }).fields({
       endBlockHash: current,
@@ -1222,8 +1276,8 @@ var XyoStakeIntentService = class extends BaseService {
       return await this.spanAsync("updateIndex", async () => {
         const currentHead = await this.chainIterator.head();
         if (isUndefined2(currentHead)) return;
-        const currentHeadHash = await PayloadBuilder8.hash(currentHead);
-        const result = await analyzeChain3(this.chainArchivist, [
+        const currentHeadHash = await PayloadBuilder7.hash(currentHead);
+        const result = await analyzeChain(this.chainArchivist, [
           new ChainStakeIntentAnalyzer("producer")
         ], currentHeadHash, this._lastIndexedBlockHash);
         const signedDeclarations = filterAs3(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
@@ -1247,164 +1301,22 @@ var XyoStakeIntentService = class extends BaseService {
 XyoStakeIntentService = _ts_decorate10([
   creatable10()
 ], XyoStakeIntentService);
-
-// src/Staker/Evm/Evm.ts
-import { assertEx as assertEx11 } from "@xylabs/assert";
-import { toAddress } from "@xylabs/hex";
-import { toEthAddress as toEthAddress2 } from "@xyo-network/chain-ethereum";
-import { StakedXyoChain__factory as StakedXyoChainFactory } from "@xyo-network/typechain";
-import { getAddress } from "ethers/address";
-var EvmChainService = class extends BaseService {
-  static {
-    __name(this, "EvmChainService");
-  }
-  get chainId() {
-    return assertEx11(this.params.id);
-  }
-  get contract() {
-    if (this.params.contract === void 0) {
-      this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(this.chainId), this.params.runner);
-    }
-    return assertEx11(this.params.contract);
-  }
-  get runner() {
-    return assertEx11(this.params.runner);
-  }
-  async active() {
-    return await this.contract.active();
-  }
-  async activeByAddressStaked(address) {
-    return await this.contract.activeByAddressStaked(getAddress(address));
-  }
-  async activeByStaker(address) {
-    return await this.contract.activeByStaker(getAddress(address));
-  }
-  async addStake(staked, amount) {
-    const result = await this.contract.addStake(getAddress(staked), amount);
-    await result.wait();
-    return true;
-  }
-  async forkedAtBlockNumber() {
-    return await this.contract.forkedAtBlockNumber();
-  }
-  async forkedAtHash() {
-    return await this.contract.forkedAtHash();
-  }
-  async forkedChainId() {
-    return toAddress(await this.contract.forkedChainId());
-  }
-  async minWithdrawalBlocks() {
-    return await this.contract.minWithdrawalBlocks();
-  }
-  async pending() {
-    return await this.contract.pending();
-  }
-  async pendingByStaker(staker) {
-    return await this.contract.pendingByStaker(getAddress(staker));
-  }
-  async removeStake(slot) {
-    const result = await this.contract.removeStake(slot);
-    await result.wait();
-    return true;
-  }
-  async rewardsContract() {
-    return await this.contract.rewardsContract();
-  }
-  async stakingTokenAddress() {
-    return await this.contract.stakingTokenAddress();
-  }
-  async withdrawStake(slot) {
-    const result = await this.contract.withdrawStake(slot);
-    await result.wait();
-    return true;
-  }
-  async withdrawn() {
-    return await this.contract.withdrawn();
-  }
-  async withdrawnByStaker(staker) {
-    return await this.contract.withdrawnByStaker(getAddress(staker));
-  }
-};
-
-// src/Staker/Memory/Memory.ts
-import { ZERO_ADDRESS } from "@xylabs/hex";
-import { isDefined as isDefined6 } from "@xylabs/typeof";
-var MemoryChainService = class extends BaseService {
-  static {
-    __name(this, "MemoryChainService");
-  }
-  _simulatedStake = 1n;
-  get chainId() {
-    return ZERO_ADDRESS;
-  }
-  async active() {
-    return await Promise.resolve(this._simulatedStake);
-  }
-  async activeByAddressStaked(_address) {
-    return await Promise.resolve(this._simulatedStake);
-  }
-  async activeByStaker(_address) {
-    return await Promise.resolve(this._simulatedStake);
-  }
-  async addStake(_staked, _amount) {
-    return await Promise.resolve(true);
-  }
-  createHandler() {
-    this._simulatedStake = isDefined6(process.env.XYO_PRODUCER_MIN_STAKE) ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE) : 1n;
-  }
-  async forkedAtBlockNumber() {
-    return await Promise.resolve(0n);
-  }
-  async forkedAtHash() {
-    return await Promise.resolve(0n);
-  }
-  async forkedChainId() {
-    return await Promise.resolve(ZERO_ADDRESS);
-  }
-  async minWithdrawalBlocks() {
-    return await Promise.resolve(1n);
-  }
-  async pending() {
-    return await Promise.resolve(0n);
-  }
-  async pendingByStaker(_staker) {
-    return await Promise.resolve(0n);
-  }
-  async removeStake(_slot) {
-    return await Promise.resolve(true);
-  }
-  async rewardsContract() {
-    return await Promise.resolve("");
-  }
-  async stakingTokenAddress() {
-    return await Promise.resolve("");
-  }
-  async withdrawStake(_slot) {
-    return await Promise.resolve(true);
-  }
-  async withdrawn() {
-    return await Promise.resolve(0n);
-  }
-  async withdrawnByStaker(_staker) {
-    return await Promise.resolve(0n);
-  }
-};
 export {
+  BaseAccountBalanceService,
   BaseAccountableService,
+  BaseBlockProducerService,
+  BaseBlockRewardService,
+  BaseElectionService,
+  BasePendingTransactionsService,
   BaseService,
-  ChainAccountBalanceServiceV2,
   ChainBlockNumberIterationService,
   DEFAULT_BLOCK_SIZE,
   EvmBlockRewardService,
   EvmChainService,
+  MemoryBlockRewardService,
   MemoryChainService,
   XYO_PRODUCER_REDECLARATION_DURATION,
   XYO_PRODUCER_REDECLARATION_WINDOW,
-  XyoBlockProducer,
-  XyoBlockRewardService,
-  XyoChainAccountBalanceService,
-  XyoElectionService,
-  XyoPendingTransactionsService,
   XyoStakeIntentService,
   XyoValidator,
   accountBalanceServiceFromArchivist,