@xyo-network/chain-services 1.8.4 → 1.10.0

package/dist/neutral/index.mjs

@@ -1,33 +1,39 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
 import { exists } from "@xylabs/exists";
-import { asHash, isHash } from "@xylabs/hex";
+import {
+  asHash,
+  isHash
+} from "@xylabs/hex";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { LRUCache } from "lru-cache";
 
 // 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";
+import {
+  AttoXL1
+} from "@xyo-network/xl1-protocol";
+import {
+  balanceSummary
+} from "@xyo-network/xl1-protocol-sdk";
 
 // src/BaseService.ts
 import { AbstractCreatable, creatable } from "@xylabs/creatable";
 import { span, spanAsync } from "@xylabs/telemetry";
 import { Mutex } from "async-mutex";
-function _ts_decorate(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_decorate, "_ts_decorate");
 var BaseService = class extends AbstractCreatable {
-  static {
-    __name(this, "BaseService");
-  }
-  static singletonInitMutex = new Mutex();
   static get singletons() {
     return globalThis["xyoServiceSingletons"] ?? (globalThis["xyoServiceSingletons"] = {});
   }
@@ -47,33 +53,21 @@ var BaseService = class extends AbstractCreatable {
     return await spanAsync(name, fn, this.tracer);
   }
 };
-BaseService = _ts_decorate([
+__publicField(BaseService, "singletonInitMutex", new Mutex());
+BaseService = __decorateClass([
   creatable()
 ], BaseService);
 var BaseAccountableService = class extends BaseService {
-  static {
-    __name(this, "BaseAccountableService");
-  }
+  // Base class for services that have an account
 };
 function creatableService() {
   return (constructor) => {
     constructor;
   };
 }
-__name(creatableService, "creatableService");
 
 // 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);
-  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_decorate2, "_ts_decorate");
 var BaseAccountBalanceService = class extends BaseService {
-  static {
-    __name(this, "BaseAccountBalanceService");
-  }
   async balances(head, address) {
     const summary = await balanceSummary({
       chainArchivist: this.params.chainArchivist,
@@ -87,12 +81,12 @@ var BaseAccountBalanceService = class extends BaseService {
     return result;
   }
 };
-BaseAccountBalanceService = _ts_decorate2([
+BaseAccountBalanceService = __decorateClass([
   creatable2()
 ], BaseAccountBalanceService);
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
-var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist) => {
+var accountBalanceServiceFromArchivist = async (archivist) => {
   const summaryArchivistCache = new LRUCache({
     max: 1e5,
     allowStale: true,
@@ -100,13 +94,13 @@ var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist
     updateAgeOnGet: true
   });
   const summaryRepository = {
-    get: /* @__PURE__ */ __name((hashes) => {
+    get: (hashes) => {
       const results = hashes.map((hash) => {
         return summaryArchivistCache.get(hash);
       }).filter(exists);
       return results;
-    }, "get"),
-    insert: /* @__PURE__ */ __name(async (payloads) => {
+    },
+    insert: async (payloads) => {
       const results = (await PayloadBuilder.addStorageMeta(payloads)).map((payload) => {
         const hash = asHash(payload.hash);
         if (isHash(hash)) {
@@ -115,28 +109,35 @@ var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist
         }
       }).filter(exists);
       return results;
-    }, "insert"),
-    next: /* @__PURE__ */ __name(() => {
+    },
+    next: () => {
       throw new Error("Not implemented");
-    }, "next")
+    }
   };
-  const service = await BaseAccountBalanceService.create({
-    chainArchivist: archivist,
-    summaryRepository
-  });
+  const service = await BaseAccountBalanceService.create({ chainArchivist: archivist, summaryRepository });
   return service;
-}, "accountBalanceServiceFromArchivist");
+};
 var accountBalanceServiceFromArchivistV2 = accountBalanceServiceFromArchivist;
 
 // src/BlockProducer/BaseBlockProducerService.ts
 import { assertEx as assertEx2 } from "@xylabs/assert";
 import { creatable as creatable3 } from "@xylabs/creatable";
 import { exists as exists2 } from "@xylabs/exists";
-import { hexToBigInt, toHex } from "@xylabs/hex";
-import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
+import {
+  hexToBigInt,
+  toHex
+} from "@xylabs/hex";
+import {
+  FixedPercentageBlockRewardDiviner,
+  FixedPercentageBlockRewardDivinerConfigSchema
+} from "@xyo-network/chain-modules";
 import { buildNextBlock, createDeclarationIntent } from "@xyo-network/chain-protocol";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness, AttoXL1 as AttoXL12, BlockNumberSchema } from "@xyo-network/xl1-protocol";
+import {
+  asBlockBoundWitness,
+  AttoXL1 as AttoXL12,
+  BlockNumberSchema
+} from "@xyo-network/xl1-protocol";
 
 // src/BlockProducer/generateTransactionFeeTransfers.ts
 import { assertEx } from "@xylabs/assert";
@@ -174,41 +175,30 @@ async function generateTransactionFeeTransfers(address, transactions) {
   }
   return payloads;
 }
-__name(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
 
 // 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_decorate3, "_ts_decorate");
 var DEFAULT_BLOCK_SIZE = 10;
 var XYO_PRODUCER_REDECLARATION_DURATION = 1e4;
 var XYO_PRODUCER_REDECLARATION_WINDOW = 500;
-var BaseBlockProducerService = class _BaseBlockProducerService extends BaseService {
-  static {
-    __name(this, "BaseBlockProducerService");
-  }
+var BaseBlockProducerService = class extends BaseService {
   _blockRewardDiviner;
   /**
-  * The default block size for a block
-  */
+   * The default block size for a block
+   */
   static get DefaultBlockSize() {
     return DEFAULT_BLOCK_SIZE;
   }
   /**
-  * The amount of time for which the producer will redeclare
-  * their intent to continue producing blocks
-  */
+   * The amount of time for which the producer will redeclare
+   * their intent to continue producing blocks
+   */
   static get RedeclarationDuration() {
     return XYO_PRODUCER_REDECLARATION_DURATION;
   }
   /**
-  * The number of blocks within which the producer will redeclare
-  * their intent to continue producing blocks
-  */
+   * The number of blocks within which the producer will redeclare
+   * their intent to continue producing blocks
+   */
   static get RedeclarationWindow() {
     return XYO_PRODUCER_REDECLARATION_WINDOW;
   }
@@ -267,22 +257,16 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
       });
     }
     const blockHex = assertEx2(toHex(block), () => "Failed to convert block to hex");
-    const blockId = new PayloadBuilder2({
-      schema: BlockNumberSchema
-    }).fields({
-      block: blockHex
-    }).build();
-    const rewards = await this._blockRewardDiviner.divine([
-      blockId
-    ]);
+    const blockId = new PayloadBuilder2({ schema: BlockNumberSchema }).fields({ block: blockHex }).build();
+    const rewards = await this._blockRewardDiviner.divine([blockId]);
     const [reward] = rewards;
     return reward;
   }
   /**
-  * Handles the producer redeclaration logic
-  * @param head The current head block
-  * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
-  */
+   * Handles the producer redeclaration logic
+   * @param head The current head block
+   * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
+   */
   async getProducerRedeclaration(head) {
     if (this.params.config.producer.disableIntentRedeclaration) return;
     const ranges = await this.stakeIntentService.getDeclaredCandidateRanges(this.address, "producer");
@@ -291,14 +275,14 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
     const [, currentDeclarationEnd] = lastRange;
     const currentBlock = head.block;
     const timeToProducerExpiration = currentDeclarationEnd - currentBlock;
-    if (timeToProducerExpiration > _BaseBlockProducerService.RedeclarationWindow) return;
-    return createDeclarationIntent(this.address, "producer", currentBlock, currentBlock + _BaseBlockProducerService.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 } = assertEx2(asBlockBoundWitness(head), () => "Invalid head block");
       const nextBlock = previousBlock + 1;
-      const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, _BaseBlockProducerService.DefaultBlockSize);
+      const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, BaseBlockProducerService.DefaultBlockSize);
       const blockPayloads = [];
       const producerRedeclarationPayload = await this.getProducerRedeclaration(head);
       if (producerRedeclarationPayload) blockPayloads.push(producerRedeclarationPayload);
@@ -312,9 +296,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.balances(head._hash, [
-            transfer.from
-          ]))[transfer.from] ?? AttoXL12(0n);
+          const balance = (await this.balanceService.balances(head._hash, [transfer.from]))[transfer.from] ?? AttoXL12(0n);
           if (balance >= totalTransferCost) {
             fundedTransfers.push(transfer);
             return tx;
@@ -325,13 +307,9 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
         }
       }))).filter(exists2);
       blockPayloads.push(...fundedTransfers);
-      const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [
-        this.account
-      ]);
+      const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account]);
       this.logger?.info(`buildBlock: ${block[0].block} with ${block[1].length} payloads`);
-      const errors = await this.validateHydratedBlockState(block, this.chainId, {
-        accountBalance: this.balanceService
-      });
+      const errors = await this.validateHydratedBlockState(block, this.chainId, { accountBalance: this.balanceService });
       if (errors.length > 0) {
         this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`);
         const rejectedTransactions = block[1];
@@ -342,47 +320,27 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
     });
   }
 };
-BaseBlockProducerService = _ts_decorate3([
+BaseBlockProducerService = __decorateClass([
   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([
+BaseBlockRewardService = __decorateClass([
   creatable4()
 ], BaseBlockRewardService);
 
 // src/BlockReward/EvmBlockRewardService.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
 import { creatable as creatable5 } from "@xylabs/creatable";
-import { toEthAddress } from "@xyo-network/chain-ethereum";
+import { toEthAddress } from "@xylabs/hex";
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
-function _ts_decorate5(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_decorate5, "_ts_decorate");
 var EvmBlockRewardService = class extends BaseBlockRewardService {
-  static {
-    __name(this, "EvmBlockRewardService");
-  }
   _contractAddress;
   get chainService() {
     return assertEx3(this.params.chainService, () => "chainService is required");
@@ -407,7 +365,7 @@ var EvmBlockRewardService = class extends BaseBlockRewardService {
     return await contract.calcBlockReward(blockNumber);
   }
 };
-EvmBlockRewardService = _ts_decorate5([
+EvmBlockRewardService = __decorateClass([
   creatable5()
 ], EvmBlockRewardService);
 
@@ -416,17 +374,7 @@ 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";
-function _ts_decorate6(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_decorate6, "_ts_decorate");
 var MemoryBlockRewardService = class extends BaseBlockRewardService {
-  static {
-    __name(this, "MemoryBlockRewardService");
-  }
   rewardFromBlockNumber = rewardFromBlockNumber(18);
   get creatorReward() {
     return assertEx4(this.params.creatorReward, () => "creatorReward is required");
@@ -458,10 +406,18 @@ var MemoryBlockRewardService = class extends BaseBlockRewardService {
     };
   }
   getRewardForBlock(blockNumber) {
-    return this.rewardFromBlockNumber(blockNumber, this.initialReward, this.stepSize, this.stepFactorNumerator, this.stepFactorDenominator, this.minRewardPerBlock, this.creatorReward);
+    return this.rewardFromBlockNumber(
+      blockNumber,
+      this.initialReward,
+      this.stepSize,
+      this.stepFactorNumerator,
+      this.stepFactorDenominator,
+      this.minRewardPerBlock,
+      this.creatorReward
+    );
   }
 };
-MemoryBlockRewardService = _ts_decorate6([
+MemoryBlockRewardService = __decorateClass([
   creatable6()
 ], MemoryBlockRewardService);
 
@@ -469,15 +425,13 @@ MemoryBlockRewardService = _ts_decorate6([
 import { assertEx as assertEx5 } from "@xylabs/assert";
 import { isDefined, isNull } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness2, isBlockBoundWitness } from "@xyo-network/xl1-protocol";
+import {
+  asBlockBoundWitness as asBlockBoundWitness2,
+  isBlockBoundWitness
+} from "@xyo-network/xl1-protocol";
 import { LRUCache as LRUCache2 } from "lru-cache";
 var ChainBlockNumberIterationService = class extends BaseService {
-  static {
-    __name(this, "ChainBlockNumberIterationService");
-  }
-  _blocksByBlockNumber = new LRUCache2({
-    max: 1e4
-  });
+  _blocksByBlockNumber = new LRUCache2({ max: 1e4 });
   get chainArchivist() {
     return assertEx5(this.params.chainArchivist);
   }
@@ -491,9 +445,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
     if (cached) return cached;
     const startingBlock = head;
     const currentBlockHash = await PayloadBuilder3.hash(startingBlock);
-    let currentBlock = (await this.chainArchivist.get([
-      currentBlockHash
-    ])).at(0);
+    let currentBlock = (await this.chainArchivist.get([currentBlockHash])).at(0);
     while (isDefined(currentBlock)) {
       assertEx5(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
       if (isBlockBoundWitness(currentBlock)) {
@@ -503,9 +455,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
         }
         const { previous } = currentBlock;
         if (isNull(previous)) break;
-        currentBlock = (await this.chainArchivist.get([
-          previous
-        ])).at(0);
+        currentBlock = (await this.chainArchivist.get([previous])).at(0);
       }
     }
     throw new Error(`Block not found: ${block}`);
@@ -528,9 +478,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
         results.push(currentBlock);
         const { previous } = currentBlock;
         if (isNull(previous)) break;
-        const nextBlock = await this.chainArchivist.get([
-          previous
-        ]);
+        const nextBlock = await this.chainArchivist.get([previous]);
         currentBlock = asBlockBoundWitness2(nextBlock[0]);
       } else {
         const hash = PayloadBuilder3.hash(currentBlock);
@@ -542,30 +490,25 @@ var ChainBlockNumberIterationService = class extends BaseService {
   async updateHead(head) {
     await Promise.resolve();
     this.params.head = head;
-    void this.emit("headUpdated", {
-      blocks: [
-        head
-      ]
-    });
+    void this.emit("headUpdated", { blocks: [head] });
   }
 };
 
 // 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 { toAddress, toEthAddress as toEthAddress2 } from "@xylabs/hex";
 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);
+      this.params.contract = StakedXyoChainFactory.connect(
+        toEthAddress2(this.chainId),
+        this.params.runner
+      );
     }
     return assertEx6(this.params.contract);
   }
@@ -631,9 +574,6 @@ var EvmChainService = class extends BaseService {
 // src/ChainService/Memory/Memory.ts
 import { ZERO_ADDRESS } from "@xylabs/hex";
 var MemoryChainService = class extends BaseService {
-  static {
-    __name(this, "MemoryChainService");
-  }
   _simulatedStake = 1n;
   get chainId() {
     return ZERO_ADDRESS;
@@ -695,17 +635,7 @@ var MemoryChainService = class extends BaseService {
 // src/ChainValidator/XyoValidator.ts
 import { assertEx as assertEx7 } from "@xylabs/assert";
 import { creatable as creatable7 } from "@xylabs/creatable";
-function _ts_decorate7(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_decorate7, "_ts_decorate");
 var XyoValidator = class extends BaseService {
-  static {
-    __name(this, "XyoValidator");
-  }
   get address() {
     return this.account.address;
   }
@@ -733,223 +663,34 @@ var XyoValidator = class extends BaseService {
   // TODO: Move to validator and inherit this class from validator
   async validatePendingTransaction(hydratedTransaction) {
     const [tx] = hydratedTransaction;
-    if ((await this.chainArchivist.get([
-      tx._hash
-    ])).length > 0) return false;
+    if ((await this.chainArchivist.get([tx._hash])).length > 0) return false;
     return await Promise.resolve(true);
   }
 };
-XyoValidator = _ts_decorate7([
+XyoValidator = __decorateClass([
   creatable7()
 ], XyoValidator);
 
-// src/DataLake/AbstractXyoDataLake.ts
-import { ObjectHasher } from "@xyo-network/hash";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { isAnyPayload } from "@xyo-network/payload-model";
-import { isHashPayload } from "@xyo-network/xl1-protocol";
-var AbstractXyoDataLake = class {
-  static {
-    __name(this, "AbstractXyoDataLake");
-  }
-  async fetch(hashes, maxDepth = 10) {
-    const results = await this.get(hashes);
-    if (maxDepth > 0) {
-      const hashPayloads = results.filter(isHashPayload);
-      const otherPayloads = results.filter((item) => !isHashPayload(item));
-      const found = await this.fetch(hashPayloads.map((item) => item.hash), maxDepth - 1);
-      const foundHashes = await Promise.all(found.map(async (item) => isAnyPayload(item) ? await PayloadBuilder4.hash(item) : ObjectHasher.hashBytes(item)));
-      const notFound = hashPayloads.filter((item) => !foundHashes.includes(item.hash));
-      return [
-        ...otherPayloads,
-        ...found,
-        ...notFound
-      ];
-    }
-    return results;
-  }
-  async trace(hash) {
-    const [result] = await this.get([
-      hash
-    ]);
-    if (isHashPayload(result)) {
-      const [payload, route] = await this.trace(result.hash);
-      return [
-        payload,
-        [
-          result,
-          ...route
-        ]
-      ];
-    }
-    return [
-      result,
-      []
-    ];
-  }
-};
-
-// src/DataLake/ArchivistXyoDataLake.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
-import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
-var ArchivistXyoDataLake = class extends AbstractXyoDataLake {
-  static {
-    __name(this, "ArchivistXyoDataLake");
-  }
-  _archivist;
-  constructor(archivist) {
-    super();
-    this._archivist = archivist;
-  }
-  async add(items) {
-    const payloads = items.filter(isAnyPayload2);
-    assertEx8(payloads.length === items.length, () => "Some items are not payloads");
-    return await this._archivist.insert(payloads);
-  }
-  async get(hashes) {
-    return await this._archivist.get(hashes);
-  }
-};
-
-// src/DataLake/HttpXyoDataLake.ts
-import { assertEx as assertEx9 } from "@xylabs/assert";
-import { AxiosJson } from "@xylabs/axios";
-import { exists as exists3 } from "@xylabs/exists";
-import { isArrayBuffer, isDefined as isDefined2 } from "@xylabs/typeof";
-import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
-import { isHashPayload as isHashPayload2 } from "@xyo-network/xl1-protocol";
-import { Axios } from "axios";
-var HttpXyoDataLake = class extends AbstractXyoDataLake {
-  static {
-    __name(this, "HttpXyoDataLake");
-  }
-  _axiosGet;
-  _axiosInsertBlob;
-  _axiosInsertJson;
-  _endpoint;
-  constructor(endpoint) {
-    super();
-    this._endpoint = endpoint;
-    this._axiosInsertJson = new AxiosJson({
-      baseURL: endpoint
-    });
-    this._axiosInsertBlob = new Axios({
-      baseURL: endpoint,
-      headers: {
-        "Content-Type": "application/octet-stream",
-        "Accept": "application/octet-stream"
-      }
-    });
-    this._axiosGet = new Axios({
-      baseURL: endpoint,
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "application/octet-stream, application/json"
-      }
-    });
-  }
-  get endpoint() {
-    return this._endpoint;
-  }
-  async add(items) {
-    const results = [];
-    for (const item of items) {
-      if (isAnyPayload3(item)) {
-        const result = await this.addPayload(item);
-        if (isAnyPayload3(result)) {
-          results.push(result);
-        } else if (isDefined2(result)) {
-          assertEx9(false, () => "Expected result to be a Payload");
-        }
-      } else if (isArrayBuffer(item)) {
-        const result = await this.addArrayBuffer(item);
-        if (isAnyPayload3(result)) {
-          results.push(result);
-        } else if (isDefined2(result)) {
-          assertEx9(false, () => "Expected result to be a Payload");
-        }
-      }
-    }
-    return results;
-  }
-  async get(hashes) {
-    return (await Promise.all(hashes.map(async (hash) => {
-      return await this.getOne(hash);
-    }))).filter(exists3);
-  }
-  async addArrayBuffer(item) {
-    const result = await this._axiosInsertBlob.post("/insert", item);
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`);
-    }
-    if (!isArrayBuffer(result.data)) {
-      throw new Error("Invalid response from server (expected a ArrayBuffer)");
-    }
-    return result.data;
-  }
-  async addPayload(item) {
-    const result = await this._axiosInsertJson.post("/insert", item);
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`);
-    }
-    if (!isAnyPayload3(result.data)) {
-      throw new Error("Invalid response from server (expected a Payload)");
-    }
-    return result.data;
-  }
-  async fetchOne(hash, maxDepth = Number.MAX_SAFE_INTEGER) {
-    if (maxDepth <= 0) {
-      return void 0;
-    }
-    const result = await this.getOne(hash);
-    if (isHashPayload2(result)) {
-      return await this.fetchOne(result.hash, maxDepth - 1);
-    }
-    return result;
-  }
-  getOne(hash) {
-    return this._axiosGet.get(`/get/${hash}`).then((response) => {
-      if (response.status < 200 || response.status >= 300) {
-        throw new Error(`Failed to get item [${response.status}]: ${response.statusText}`);
-      }
-      if (!isAnyPayload3(response.data)) {
-        throw new Error("Invalid response from server (expected a Payload)");
-      }
-      return response.data;
-    });
-  }
-};
-
 // src/Election/BaseElectionService.ts
-import { assertEx as assertEx10 } from "@xylabs/assert";
+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";
-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);
-  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_decorate8, "_ts_decorate");
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 var BaseElectionService = class extends BaseService {
-  static {
-    __name(this, "BaseElectionService");
-  }
   get chainIterator() {
-    return assertEx10(this.params.chainIterator, () => "No chain iterator");
+    return assertEx8(this.params.chainIterator, () => "No chain iterator");
   }
   get chainStakeViewer() {
-    return assertEx10(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx8(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx10(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx8(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     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);
     });
   }
@@ -960,131 +701,100 @@ var BaseElectionService = class extends BaseService {
     return creatorArray.slice(0, maxSize);
   }
 };
-BaseElectionService = _ts_decorate8([
+BaseElectionService = __decorateClass([
   creatable8()
 ], BaseElectionService);
 
 // src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
 import { filterAs, filterAsync } from "@xylabs/array";
-import { assertEx as assertEx11 } from "@xylabs/assert";
+import { assertEx as assertEx9 } from "@xylabs/assert";
 import { creatable as creatable9 } from "@xylabs/creatable";
-import { exists as exists4 } from "@xylabs/exists";
+import { exists as exists3 } from "@xylabs/exists";
 import { forget } from "@xylabs/forget";
-import { isDefined as isDefined3, isUndefined } from "@xylabs/typeof";
+import { isDefined as isDefined2, isUndefined } from "@xylabs/typeof";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
 import { findMostRecentBlock } from "@xyo-network/chain-protocol";
-import { asBlockBoundWitnessWithHashStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import {
+  asBlockBoundWitnessWithHashStorageMeta,
+  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 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);
+var bundledPayloadToHydratedTransaction = async (payload) => {
+  const withStorageMeta = await PayloadBuilder5.addStorageMeta(payload.payloads);
   const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
   if (tx) {
-    return [
-      tx,
-      withStorageMeta.filter((p) => p._hash !== payload.root)
-    ];
+    return [tx, withStorageMeta.filter((p) => p._hash !== payload.root)];
   }
-}, "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) => {
+var hydratedTransactionToPayloadBundle = (transaction) => {
   const root = transaction[0]._hash;
   return bundle(root, transaction);
-}, "hydratedTransactionToPayloadBundle");
-var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder7.omitStorageMeta(p));
-  return new PayloadBuilder7({
-    schema: PayloadBundleSchema
-  }).fields({
-    payloads,
-    root
-  }).build();
-}, "bundle");
+};
+var bundle = (root, transaction) => {
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder6.omitStorageMeta(p));
+  return new PayloadBuilder6({ schema: PayloadBundleSchema }).fields({ payloads, root }).build();
+};
 
 // 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);
-  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_decorate9, "_ts_decorate");
-var BasePendingTransactionsService = class _BasePendingTransactionsService extends BaseService {
-  static {
-    __name(this, "BasePendingTransactionsService");
-  }
-  static MutexPriority = {
-    /**
-    * Priority for inserting new transactions
-    */
-    InsertNewTransactions: 5,
-    /**
-    * Priority for reading pending transactions
-    */
-    ReadTransactions: 3,
-    /**
-    * Priority for removing finalized/expired/rejected transactions
-    */
-    PurgeTransactions: 1
-  };
+var BasePendingTransactionsService = class extends BaseService {
   /**
-  * A mutex to ensure that the counting the number of pending transactions is
-  * not called concurrently
-  */
+   * A mutex to ensure that the counting the number of pending transactions is
+   * not called concurrently
+   */
   _countPendingTransactionsMutex = new Mutex2();
   /**
-  * A local Archivist optimized for fast retrieval that stores only validated
-  * pending transactions
-  */
+   * A local Archivist optimized for fast retrieval that stores only validated
+   * pending transactions
+   */
   _curatedPendingBundledTransactionsArchivist;
   /**
-  * The last count of total pending transactions
-  */
+   * The last count of total pending transactions
+   */
   _pendingTransactionsCount = 0;
   /**
-  * A set of transaction hashes that are pending removal from the
-  * curated pending transactions archivist. This is used to track
-  * which transactions need to be removed from the archivist.
-  */
+   * A set of transaction hashes that are pending removal from the
+   * curated pending transactions archivist. This is used to track
+   * which transactions need to be removed from the archivist.
+   */
   _removablePendingTransactionHashes = /* @__PURE__ */ new Set();
   /**
-  * A mutex to ensure that the curated pending transactions archivist is
-  * updated in a thread-safe manner
-  */
+   * A mutex to ensure that the curated pending transactions archivist is
+   * updated in a thread-safe manner
+   */
   _updateCuratedPendingTransactionsArchivistMutex = new Mutex2();
   get chainArchivist() {
-    return assertEx11(this.params.chainArchivist, () => "No completed blocks with data archivist");
+    return assertEx9(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get chainId() {
-    return assertEx11(this.params.chainId, () => "No chain id");
+    return assertEx9(this.params.chainId, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx11(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx11(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+    return assertEx9(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 assertEx9(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
-    this._curatedPendingBundledTransactionsArchivist = await MemoryArchivist.create({
-      account: "random"
-    });
+    this._curatedPendingBundledTransactionsArchivist = await MemoryArchivist.create({ account: "random" });
     this.pendingBundledTransactionsArchivist.on("inserted", ({ payloads }) => {
       forget(this.insertNewTransactions(payloads));
     });
@@ -1096,11 +806,14 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       this.markAnyIncludedTransactionsForRemoval(payloads);
       forget(this.cleanupWorker());
     });
-    const pendingTransactionsCounter = this.meter?.createObservableUpDownCounter("xyo_pending_transactions_counter", {
-      description: "The current number of pending transactions",
-      valueType: ValueType.INT,
-      unit: "1"
-    });
+    const pendingTransactionsCounter = this.meter?.createObservableUpDownCounter(
+      "xyo_pending_transactions_counter",
+      {
+        description: "The current number of pending transactions",
+        valueType: ValueType.INT,
+        unit: "1"
+      }
+    );
     pendingTransactionsCounter?.addCallback((observer) => {
       observer.observe(this.pendingTransactionsCount);
     });
@@ -1108,9 +821,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
   async getPendingTransactions(head, limit) {
     return await this.spanAsync("getPendingTransactions", async () => {
       return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        let [lastHead] = filterAs(await this.chainArchivist.get([
-          head
-        ]), asBlockBoundWitnessWithHashStorageMeta);
+        let [lastHead] = filterAs(await this.chainArchivist.get([head]), asBlockBoundWitnessWithHashStorageMeta);
         if (isUndefined(lastHead)) return [];
         await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
         const foundPendingTransactions = [];
@@ -1124,7 +835,9 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           if (pendingBundledTransactions.length === 0) break;
           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(exists4);
+          const transactions = (await Promise.all(
+            undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p))
+          )).filter(exists3);
           const activeTransactions = transactions.filter(isTransactionActive(lastHead.block + 1));
           foundPendingTransactions.push(...activeTransactions);
         }
@@ -1135,14 +848,14 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           }
         }
         return foundPendingTransactions;
-      }, _BasePendingTransactionsService.MutexPriority.ReadTransactions);
+      }, BasePendingTransactionsService.MutexPriority.ReadTransactions);
     });
   }
   async cleanupWorker() {
     return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
       const lastHead = await findMostRecentBlock(this.chainArchivist);
-      if (isDefined3(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
-    }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
+      if (isDefined2(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
+    }, BasePendingTransactionsService.MutexPriority.PurgeTransactions);
   }
   async countPendingTransactions() {
     if (this._countPendingTransactionsMutex.isLocked()) return;
@@ -1165,11 +878,9 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
         const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map(async (tx) => {
           return await bundledPayloadToHydratedTransaction(tx);
-        }))).filter(exists4);
+        }))).filter(exists3);
         const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
-          const errors = await validateTransaction(tx, this.chainId, [
-            TransactionJsonSchemaValidator
-          ]);
+          const errors = await validateTransaction(tx, this.chainId, [TransactionJsonSchemaValidator]);
           if (errors.length > 0) {
             this.logger?.warn("validateTransaction", errors);
           }
@@ -1179,15 +890,15 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           const bundledTransactions = validTransactions.map((tx) => hydratedTransactionToPayloadBundle(tx));
           await this.pendingBundledTransactionsLocalArchivist.insert(bundledTransactions);
         }
-      }, _BasePendingTransactionsService.MutexPriority.InsertNewTransactions);
+      }, BasePendingTransactionsService.MutexPriority.InsertNewTransactions);
     });
   }
   /**
-  * Marks any included transactions in the provided payloads for removal preventing them
-  * from being included in the curated pending transactions archivist and from being offered
-  * during the next retrieval of pending transactions.
-  * @param payloads An array of payloads that may contain transactions.
-  */
+   * Marks any included transactions in the provided payloads for removal preventing them
+   * from being included in the curated pending transactions archivist and from being offered
+   * during the next retrieval of pending transactions.
+   * @param payloads An array of payloads that may contain transactions.
+   */
   markAnyIncludedTransactionsForRemoval(payloads) {
     const hashes = payloads.filter(isTransactionBoundWitnessWithStorageMeta).map((p) => p._hash);
     for (const hash of hashes) {
@@ -1198,10 +909,8 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
     return await this.spanAsync("pruneCuratedPendingTransactionsArchivist", async () => {
       const foundPendingTransactionsToDeleteHashes = [];
       let cursor;
-      let [lastHead] = filterAs(await this.chainArchivist.get([
-        head
-      ]), asBlockBoundWitnessWithHashStorageMeta);
-      while (isDefined3(lastHead)) {
+      let [lastHead] = filterAs(await this.chainArchivist.get([head]), asBlockBoundWitnessWithHashStorageMeta);
+      while (isDefined2(lastHead)) {
         const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
           limit: 100,
           order: "asc",
@@ -1212,14 +921,18 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         }
         cursor = pendingBundledTransactions.at(-1)?._sequence;
         const deletedTransactionBundles = pendingBundledTransactions.filter((tx) => this._removablePendingTransactionHashes.has(tx.root));
-        foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists4));
+        foundPendingTransactionsToDeleteHashes.push(
+          ...deletedTransactionBundles.map((tx) => tx._hash).filter(exists3)
+        );
         const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-        const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists4);
+        const transactions = (await Promise.all(
+          undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p))
+        )).filter(exists3);
         const expiredTransactions = transactions.filter(isTransactionExpired(lastHead.block + 1));
         const expiredBundleHashes = expiredTransactions.map((expiredHydratedTx) => (
           // Find the corresponding payload bundle hash for the expired transaction
           pendingBundledTransactions.find((bundledTx) => bundledTx.root === expiredHydratedTx[0]._hash)?._hash
-        )).filter(exists4);
+        )).filter(exists3);
         foundPendingTransactionsToDeleteHashes.push(...expiredBundleHashes);
       }
       const deletedHashes = await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes);
@@ -1235,65 +948,86 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
     });
   }
 };
-BasePendingTransactionsService = _ts_decorate9([
+__publicField(BasePendingTransactionsService, "MutexPriority", {
+  /**
+   * Priority for inserting new transactions
+   */
+  InsertNewTransactions: 5,
+  /**
+   * Priority for reading pending transactions
+   */
+  ReadTransactions: 3,
+  /**
+   * Priority for removing finalized/expired/rejected transactions
+   */
+  PurgeTransactions: 1
+});
+BasePendingTransactionsService = __decorateClass([
   creatable9()
 ], BasePendingTransactionsService);
-var isTransactionExpired = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.exp < block, "isTransactionExpired");
-var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block, "isTransactionActive");
+var isTransactionExpired = (block) => ([txBw]) => txBw.exp < block;
+var isTransactionActive = (block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block;
 
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
-import { exists as exists5 } from "@xylabs/exists";
+import { exists as exists4 } from "@xylabs/exists";
 import { asOptionalBoundWitness } 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) => {
+var getBlockSignedStakeDeclarations = async (block, archivist, intent) => {
   const blockData = await archivist.get(block.payload_hashes);
   const bwsFromBlock = filterAs2(blockData, asOptionalBoundWitness);
   const bwsFromBlockWithDeclarations = bwsFromBlock.filter((bw) => payloadSchemasContains(bw, ChainStakeIntentSchema));
   const validBlockBwsWithDeclarations = await filterToValidSignedBoundWitnesses(bwsFromBlockWithDeclarations);
   return (await Promise.all(validBlockBwsWithDeclarations.map(async (bw) => {
-    const stakeIntentHashes = validBlockBwsWithDeclarations.flatMap(mapBoundWitnessToStakeIntentHashes).filter(exists5);
+    const stakeIntentHashes = validBlockBwsWithDeclarations.flatMap(mapBoundWitnessToStakeIntentHashes).filter(exists4);
     const payloads = await archivist.get(stakeIntentHashes);
     const stakeIntents = filterAs2(payloads, asChainStakeIntent).filter((p) => p.intent === intent).filter((p) => bw.addresses.includes(p.from));
     return stakeIntents;
   }))).flat();
-}, "getBlockSignedStakeDeclarations");
-var filterToValidSignedBoundWitnesses = /* @__PURE__ */ __name(async (bws) => {
+};
+var filterToValidSignedBoundWitnesses = async (bws) => {
   const validBwIndexes = await Promise.all(bws.map((bw) => BoundWitnessWrapper.parse(bw).getValid()));
   return bws.filter((_, index) => validBwIndexes[index]);
-}, "filterToValidSignedBoundWitnesses");
-var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
+};
+var mapBoundWitnessToStakeIntentHashes = (bw) => {
   return bw.payload_schemas.map((schema, index) => schema === ChainStakeIntentSchema ? bw.payload_hashes[index] : void 0);
-}, "mapBoundWitnessToStakeIntentHashes");
+};
 
 // src/StakeIntent/XyoStakeIntentService.ts
 import { filterAs as filterAs3 } from "@xylabs/array";
-import { assertEx as assertEx12 } from "@xylabs/assert";
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { creatable as creatable10 } from "@xylabs/creatable";
-import { asAddress } from "@xylabs/hex";
+import {
+  asAddress
+} from "@xylabs/hex";
 import { isUndefined as isUndefined2 } from "@xylabs/typeof";
-import { analyzeChain, ChainStakeIntentAnalyzer, isChainSummaryStakeIntent } from "@xyo-network/chain-analyze";
-import { DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS, findFirstMatching, IntervalMap } from "@xyo-network/chain-utils";
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta, asChainIndexingServiceStateWithStorageMeta, asChainStakeIntent as asChainStakeIntent2, ChainIndexingServiceStateSchema, isChainIndexingServiceState } from "@xyo-network/xl1-protocol";
+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,
+  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";
-function _ts_decorate10(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_decorate10, "_ts_decorate");
 var ACTIVE_STAKE_TTL = 1e3 * 60 * 60 * 2;
 var NO_ACTIVE_STAKE_TTL = 1e3 * 2;
 var STAKE_CACHE_MAX_ENTRIES = 1e4;
 var XyoStakeIntentService = class extends BaseService {
-  static {
-    __name(this, "XyoStakeIntentService");
-  }
   // TODO: Use hash instead of block number to handle chain reorgs
   _lastIndexedBlockHash = void 0;
   // TODO: Interval tree per declaration (bank, validator, etc.)
@@ -1304,21 +1038,19 @@ var XyoStakeIntentService = class extends BaseService {
   // in performance for small sets, and (most importantly) easily
   // persisted so we can recover state on restart.
   _producers = new IntervalMap();
-  _stakeCache = new LRUCache3({
-    max: STAKE_CACHE_MAX_ENTRIES
-  });
+  _stakeCache = new LRUCache3({ max: STAKE_CACHE_MAX_ENTRIES });
   _updateMutex = new Mutex3();
   get chainArchivist() {
-    return assertEx12(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx10(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainIterator() {
-    return assertEx12(this.params.chainIterator, () => "chainIterator not set");
+    return assertEx10(this.params.chainIterator, () => "chainIterator not set");
   }
   get chainStakeViewer() {
-    return assertEx12(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx10(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx12(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx10(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
     this.chainIterator.on("headUpdated", async () => {
@@ -1326,22 +1058,20 @@ 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) {
     await Promise.resolve();
-    assertEx12(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+    assertEx10(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
     const results = this._producers.get(address);
     return results ?? [];
   }
   async getDeclaredCandidatesForBlock(block, intent) {
     return await this.spanAsync("getDeclaredCandidatesForBlock", async () => {
-      assertEx12(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+      assertEx10(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
-      const candidates = [
-        ...results
-      ];
+      const candidates = [...results];
       const requiredMinimumStake = this.getRequiredMinimumStakeForIntent(intent);
       const validCandidates = await this.filterToValidStake(candidates, this.chainStakeViewer, requiredMinimumStake);
       return validCandidates;
@@ -1363,62 +1093,41 @@ var XyoStakeIntentService = class extends BaseService {
     await this.updateIndex(true);
   }
   async filterToValidStake(candidates, chainStakeViewer, requiredMinimumStake) {
-    const candidatesWithStake = await Promise.all(candidates.map(async (candidate) => {
-      const stake = this._stakeCache.get(candidate);
-      if (stake === void 0) {
-        const activeStake = await chainStakeViewer.activeByAddressStaked(`${candidate}`);
-        if (activeStake > 0n) {
-          this._stakeCache.set(candidate, activeStake, {
-            ttl: ACTIVE_STAKE_TTL
-          });
+    const candidatesWithStake = await Promise.all(
+      candidates.map(async (candidate) => {
+        const stake = this._stakeCache.get(candidate);
+        if (stake === void 0) {
+          const activeStake = await chainStakeViewer.activeByAddressStaked(`${candidate}`);
+          if (activeStake > 0n) {
+            this._stakeCache.set(candidate, activeStake, { ttl: ACTIVE_STAKE_TTL });
+          } else {
+            this._stakeCache.set(candidate, activeStake, { ttl: NO_ACTIVE_STAKE_TTL });
+          }
+          return { candidate, stake: activeStake };
         } else {
-          this._stakeCache.set(candidate, activeStake, {
-            ttl: NO_ACTIVE_STAKE_TTL
-          });
+          return { candidate, stake };
         }
-        return {
-          candidate,
-          stake: activeStake
-        };
-      } else {
-        return {
-          candidate,
-          stake
-        };
-      }
-    }));
+      })
+    );
     return candidatesWithStake.filter(({ stake }) => stake >= requiredMinimumStake).map(({ candidate }) => candidate);
   }
   async persistState(current) {
     const state = this._producers.serialize();
-    const payload = new PayloadBuilder8({
-      schema: ChainIndexingServiceStateSchema
-    }).fields({
-      endBlockHash: current,
-      state
-    }).build();
-    await this.stakeIntentStateArchivist.insert([
-      payload
-    ]);
+    const payload = new PayloadBuilder7({ schema: ChainIndexingServiceStateSchema }).fields({ endBlockHash: current, state }).build();
+    await this.stakeIntentStateArchivist.insert([payload]);
   }
   async recoverState(current) {
-    const currentBlock = assertEx12(asBlockBoundWitness3((await this.chainArchivist.get([
-      current
-    ]))?.[0]), () => `Block ${current} not found`);
+    const currentBlock = assertEx10(asBlockBoundWitness3((await this.chainArchivist.get([current]))?.[0]), () => `Block ${current} not found`);
     const currentBlockNum = currentBlock.block;
-    const opts = {
-      ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS
-    };
+    const opts = { ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS };
     while (true) {
-      const predicate = /* @__PURE__ */ __name((p) => {
+      const predicate = (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 indexed = (await this.chainArchivist.get([state.endBlockHash]))?.[0];
         const indexedBlock = asBlockBoundWitnessWithStorageMeta(indexed);
         if (indexedBlock) {
           const indexedBlockNum = indexedBlock.block;
@@ -1443,10 +1152,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 analyzeChain(this.chainArchivist, [
-          new ChainStakeIntentAnalyzer("producer")
-        ], currentHeadHash, this._lastIndexedBlockHash);
+        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);
         if (currentHead.block === void 0) return;
         const currentHeadBlockNum = currentHead.block;
@@ -1465,12 +1172,10 @@ var XyoStakeIntentService = class extends BaseService {
     });
   }
 };
-XyoStakeIntentService = _ts_decorate10([
+XyoStakeIntentService = __decorateClass([
   creatable10()
 ], XyoStakeIntentService);
 export {
-  AbstractXyoDataLake,
-  ArchivistXyoDataLake,
   BaseAccountBalanceService,
   BaseAccountableService,
   BaseBlockProducerService,
@@ -1482,7 +1187,6 @@ export {
   DEFAULT_BLOCK_SIZE,
   EvmBlockRewardService,
   EvmChainService,
-  HttpXyoDataLake,
   MemoryBlockRewardService,
   MemoryChainService,
   XYO_PRODUCER_REDECLARATION_DURATION,