@xyo-network/chain-services 1.5.35 → 1.5.36

package/dist/neutral/index.mjs

@@ -2,72 +2,31 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
-import { isHash } from "@xylabs/hex";
-import { isDefined } from "@xylabs/typeof";
+import { exists } from "@xylabs/exists";
+import { asHash, isHash } from "@xylabs/hex";
 import { analyzeChain, BalanceAnalyzer, ChainSummaryBalancesSchema, isChainSummaryBalances } from "@xyo-network/chain-analyze";
-import { isPositiveBigInt } from "@xyo-network/chain-protocol";
-import { isBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
-var accountBalanceServiceFromArchivist = /* @__PURE__ */ __name(async (archivist, head) => {
-  let allAddressesBalances = {
-    schema: ChainSummaryBalancesSchema,
-    balances: {},
-    firstBlock: null,
-    lastBlock: null
-  };
-  const result = {
-    getBalance: /* @__PURE__ */ __name((address) => {
-      if (allAddressesBalances === void 0) {
-        return "00";
-      }
-      const signedValue = allAddressesBalances.balances[address] ?? {
-        positive: "00"
-      };
-      return isPositiveBigInt(signedValue) ? signedValue.positive : "00";
-    }, "getBalance"),
-    getBalances: /* @__PURE__ */ __name(() => {
-      return Object.fromEntries(Object.entries(allAddressesBalances.balances).map(([key, value]) => [
-        key,
-        isPositiveBigInt(value) ? value.positive : "0"
-      ]));
-    }, "getBalances"),
-    name: "ArchivistAccountBalanceService",
-    async sync(head2) {
-      const analysis = await analyzeChain(archivist, [
-        new BalanceAnalyzer()
-      ], head2, null, -1n);
-      allAddressesBalances = analysis.find(isChainSummaryBalances) ?? {
-        schema: ChainSummaryBalancesSchema,
-        balances: {},
-        firstBlock: null,
-        lastBlock: null
-      };
-      return await Promise.resolve();
-    }
-  };
-  if (isHash(head)) {
-    await result.sync(head);
-  }
-  archivist.on("inserted", ({ payloads }) => {
-    const block = payloads.find((p) => isBlockBoundWitnessWithStorageMeta(p));
-    if (isDefined(block)) {
-      void result.sync(block._hash);
-    }
-  });
-  return result;
-}, "accountBalanceServiceFromArchivist");
-
-// src/AccountBalance/XyoChainAccountBalanceService.ts
-import { assertEx } from "@xylabs/assert";
-import { toHex } from "@xylabs/hex";
-import { analyzeChain as analyzeChain2, BalanceAnalyzer as BalanceAnalyzer2, ChainSummaryBalancesSchema as ChainSummaryBalancesSchema2, isChainSummaryBalances as isChainSummaryBalances2 } from "@xyo-network/chain-analyze";
-import { toPositiveBigInt } from "@xyo-network/chain-protocol";
 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
+import { creatable as creatable2 } from "@xylabs/creatable";
+import { AttoXL1 } from "@xyo-network/xl1-protocol";
+import { balanceSummary } from "@xyo-network/xl1-protocol-sdk";
 
 // src/BaseService.ts
-import { BaseEmitter } from "@xylabs/events";
+import { AbstractCreatable, creatable } from "@xylabs/creatable";
 import { span, spanAsync } from "@xylabs/telemetry";
 import { Mutex } from "async-mutex";
-var BaseService = class extends BaseEmitter {
+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");
   }
@@ -75,23 +34,14 @@ var BaseService = class extends BaseEmitter {
   static get singletons() {
     return globalThis["xyoServiceSingletons"] ?? (globalThis["xyoServiceSingletons"] = {});
   }
-  get name() {
-    return this.constructor.name;
-  }
-  static async create(params) {
-    const result = new this(params);
-    if (result.name === "BaseService") throw new Error("Cannot create BaseService");
-    await result.createHandler();
-    return result;
-  }
   static initSingleton(params) {
     if (this.singletons[this.name]) throw new Error(`Singleton already initialized for ${this.name}`);
     return this.singletonInitMutex.runExclusive(async () => {
       return await this.create(params);
     });
   }
-  createHandler() {
-    return;
+  paramsHandler(params) {
+    return params;
   }
   span(name, fn) {
     return span(name, fn, this.tracer);
@@ -100,6 +50,9 @@ var BaseService = class extends BaseEmitter {
     return await spanAsync(name, fn, this.tracer);
   }
 };
+BaseService = _ts_decorate([
+  creatable()
+], BaseService);
 var BaseAccountableService = class extends BaseService {
   static {
     __name(this, "BaseAccountableService");
@@ -112,14 +65,123 @@ function creatableService() {
 }
 __name(creatableService, "creatableService");
 
+// src/AccountBalance/ChainAccountBalanceServiceV2.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 ChainAccountBalanceServiceV2 = class extends BaseService {
+  static {
+    __name(this, "ChainAccountBalanceServiceV2");
+  }
+  async balances(head, address) {
+    const summary = await balanceSummary({
+      chainArchivist: this.params.chainArchivist,
+      summaryRepository: this.params.summaryRepository,
+      head
+    });
+    const result = {};
+    for (const addr of address) {
+      result[addr] = AttoXL1(summary[addr] ?? 0n);
+    }
+    return result;
+  }
+};
+ChainAccountBalanceServiceV2 = _ts_decorate2([
+  creatable2()
+], ChainAccountBalanceServiceV2);
+
+// 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) => {
+  const summaryArchivistCache = new LRUCache({
+    max: 1e5,
+    allowStale: true,
+    noDisposeOnSet: false,
+    updateAgeOnGet: true
+  });
+  const summaryRepository = {
+    get: /* @__PURE__ */ __name((hashes) => {
+      const results = hashes.map((hash) => {
+        return summaryArchivistCache.get(hash);
+      }).filter(exists);
+      return results;
+    }, "get"),
+    insert: /* @__PURE__ */ __name(async (payloads) => {
+      const results = (await PayloadBuilder.addStorageMeta(payloads)).map((payload) => {
+        const hash = asHash(payload.hash);
+        if (isHash(hash)) {
+          summaryArchivistCache.set(hash, payload);
+          return payload;
+        }
+      }).filter(exists);
+      return results;
+    }, "insert"),
+    next: /* @__PURE__ */ __name(() => {
+      throw new Error("Not implemented");
+    }, "next")
+  };
+  const service = await ChainAccountBalanceServiceV2.create({
+    chainArchivist: archivist,
+    summaryRepository
+  });
+  return service;
+}, "accountBalanceServiceFromArchivistV2");
+
 // src/AccountBalance/XyoChainAccountBalanceService.ts
-function _ts_decorate(decorators, target, key, desc) {
+import { assertEx } 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_decorate, "_ts_decorate");
+__name(_ts_decorate3, "_ts_decorate");
 var XyoChainAccountBalanceService = class extends BaseService {
   static {
     __name(this, "XyoChainAccountBalanceService");
@@ -136,21 +198,22 @@ var XyoChainAccountBalanceService = class extends BaseService {
   get chainArchivist() {
     return assertEx(this.params.chainArchivist, () => "chainArchivist is required");
   }
-  getBalance(address) {
-    return toPositiveBigInt(this._balances[address] ?? {
-      positive: toHex(0n)
-    }).positive;
-  }
-  getBalances() {
+  balances(head, address) {
     const result = {};
-    const entries = Object.entries(this._balances);
-    for (const [address, balance] of entries) {
-      result[address] = toPositiveBigInt(balance).positive;
+    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 PayloadBuilder({
+    const startingBalances = new PayloadBuilder2({
       schema: ChainSummaryBalancesSchema2
     }).fields({
       balances: this._balances,
@@ -170,19 +233,20 @@ var XyoChainAccountBalanceService = class extends BaseService {
     if (this._lastBlock === null) this._lastBlock = allAddressesBalances.lastBlock;
   }
 };
-XyoChainAccountBalanceService = _ts_decorate([
-  creatableService()
+XyoChainAccountBalanceService = _ts_decorate3([
+  creatable3()
 ], XyoChainAccountBalanceService);
 
 // src/BlockProducer/XyoBlockProducer.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
-import { exists } from "@xylabs/exists";
-import { hexToBigInt, toHex as toHex2 } from "@xylabs/hex";
-import { isUndefined } from "@xylabs/typeof";
+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 { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
-import { buildBlock } from "@xyo-network/chain-protocol";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness, BlockNumberSchema, ChainStakeIntentSchema } from "@xyo-network/xl1-protocol";
+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";
 
 // src/BlockProducer/generateTransactionFeeTransfers.ts
 import { assertEx as assertEx2 } from "@xylabs/assert";
@@ -224,24 +288,48 @@ async function generateTransactionFeeTransfers(address, transactions) {
 __name(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
 
 // src/BlockProducer/XyoBlockProducer.ts
-function _ts_decorate2(decorators, target, key, desc) {
+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_decorate2, "_ts_decorate");
+__name(_ts_decorate4, "_ts_decorate");
 var DEFAULT_BLOCK_SIZE = 10;
-var XYO_PRODUCER_RESTAKE_DURATION = 1e4;
-var XYO_PRODUCER_RESTAKE_WINDOW = 500n;
+var XYO_PRODUCER_REDECLARATION_DURATION = 1e4;
+var XYO_PRODUCER_REDECLARATION_WINDOW = 500;
 var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
   static {
     __name(this, "XyoBlockProducer");
   }
   _blockRewardDiviner;
+  /**
+  * 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
+  */
+  static get RedeclarationDuration() {
+    return XYO_PRODUCER_REDECLARATION_DURATION;
+  }
+  /**
+  * The number of blocks within which the producer will redeclare
+  * their intent to continue producing blocks
+  */
+  static get RedeclarationWindow() {
+    return XYO_PRODUCER_REDECLARATION_WINDOW;
+  }
+  /**
+  * Should the producer should redeclare
+  * their intent to continue producing blocks
+  */
+  static get RedeclareIntent() {
+    return isDefined2(process.env.XYO_PRODUCER_SKIP_REDECLARE_INTENT) ? false : true;
+  }
   get address() {
     return this.account.address;
   }
@@ -254,8 +342,8 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
   get chainArchivist() {
     return assertEx3(this.params.chainArchivist, () => "chainArchivist is required");
   }
-  get chainInfo() {
-    return assertEx3(this.params.chainInformation, () => "chainInfo is required");
+  get chainId() {
+    return assertEx3(this.params.chainId, () => "chainId is required");
   }
   get electionService() {
     return assertEx3(this.params.electionService, () => "electionService is required");
@@ -279,9 +367,9 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
     return assertEx3(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
   }
   async next(head) {
-    if (head.chain !== this.chainInfo.id) return;
+    if (head.chain !== this.chainId) return;
     const leaders = await this.electionService.getCreatorCommitteeForNextBlock(head);
-    if (leaders?.[0] !== this.address) return;
+    if (!leaders.includes(this.address)) return;
     return this.proposeNextValidBlock(head);
   }
   async getBlockRewardTransfer(block) {
@@ -296,8 +384,8 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
         }
       });
     }
-    const blockHex = assertEx3(toHex2(block), () => "Failed to convert block to hex");
-    const blockId = new PayloadBuilder2({
+    const blockHex = assertEx3(toHex(block), () => "Failed to convert block to hex");
+    const blockId = new PayloadBuilder3({
       schema: BlockNumberSchema
     }).fields({
       block: blockHex
@@ -314,24 +402,15 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
   * @returns
   */
   async getProducerRedeclaration(head) {
-    const redeclareIntent = process.env.XYO_PRODUCER_REDECLARE_INTENT;
-    if (isUndefined(redeclareIntent)) return;
+    if (!_XyoBlockProducer.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 > XYO_PRODUCER_RESTAKE_WINDOW) return;
-    const intent = new PayloadBuilder2({
-      schema: ChainStakeIntentSchema
-    }).fields({
-      from: this.address,
-      intent: "producer",
-      nbf: currentBlock,
-      exp: currentBlock + XYO_PRODUCER_RESTAKE_DURATION
-    }).build();
-    return intent;
+    if (timeToProducerExpiration > _XyoBlockProducer.RedeclarationWindow) return;
+    return createDeclarationIntent(this.address, "producer", currentBlock, currentBlock + _XyoBlockProducer.RedeclarationDuration);
   }
   async proposeNextValidBlock(head, validateBalances = false) {
     return await this.spanAsync("proposeNextValidBlock", async () => {
@@ -346,12 +425,15 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
       if (rewardTransferPayload) blockPayloads.push(rewardTransferPayload);
       const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions);
       const fundedTransfers = [];
-      const fundedNextBlockTransactions = nextBlockTransactions.map((tx) => {
+      const fundedNextBlockTransactions = (await Promise.all(nextBlockTransactions.map(async (tx) => {
         const transfer = transactionTransfers.find((txTransfer) => txTransfer.from === tx[0].from);
         if (!transfer) return;
         const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? "00"), 0n);
         if (validateBalances) {
-          if (hexToBigInt(this.balanceService.getBalance(transfer.from)) >= totalTransferCost) {
+          const balance = (await this.balanceService.balances(head._hash, [
+            transfer.from
+          ]))[transfer.from] ?? AttoXL14(0n);
+          if (balance >= totalTransferCost) {
             fundedTransfers.push(transfer);
             return tx;
           }
@@ -359,13 +441,13 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
           fundedTransfers.push(transfer);
           return tx;
         }
-      }).filter(exists);
+      }))).filter(exists2);
       blockPayloads.push(...fundedTransfers);
-      const block = await buildBlock(head, fundedNextBlockTransactions, blockPayloads, [
+      const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [
         this.account
       ]);
       this.logger?.warn(`buildBlock: ${block[0].block} with ${block[1].length} payloads`);
-      const errors = await this.validateHydratedBlockState(block, this.chainInfo.id, {
+      const errors = await this.validateHydratedBlockState(block, this.chainId, {
         accountBalance: this.balanceService
       });
       if (errors.length > 0) {
@@ -378,21 +460,22 @@ var XyoBlockProducer = class _XyoBlockProducer extends BaseService {
     });
   }
 };
-XyoBlockProducer = _ts_decorate2([
-  creatableService()
+XyoBlockProducer = _ts_decorate4([
+  creatable4()
 ], XyoBlockProducer);
 
 // src/BlockReward/EvmBlockRewardService.ts
 import { assertEx as assertEx4 } 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";
-function _ts_decorate3(decorators, target, key, desc) {
+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_decorate3, "_ts_decorate");
+__name(_ts_decorate5, "_ts_decorate");
 var EvmBlockRewardService = class extends BaseService {
   static {
     __name(this, "EvmBlockRewardService");
@@ -421,21 +504,22 @@ var EvmBlockRewardService = class extends BaseService {
     return await contract.calcBlockReward(blockNumber);
   }
 };
-EvmBlockRewardService = _ts_decorate3([
-  creatableService()
+EvmBlockRewardService = _ts_decorate5([
+  creatable5()
 ], EvmBlockRewardService);
 
 // src/BlockReward/XyoBlockRewardService.ts
 import { assertEx as assertEx5 } 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_decorate4(decorators, target, key, desc) {
+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_decorate4, "_ts_decorate");
+__name(_ts_decorate6, "_ts_decorate");
 function _ts_metadata(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
@@ -477,8 +561,8 @@ var XyoBlockRewardService = class extends BaseService {
     return this.rewardFromBlockNumber(blockNumber, this.initialReward, this.stepSize, this.stepFactorNumerator, this.stepFactorDenominator, this.minRewardPerBlock, this.creatorReward);
   }
 };
-XyoBlockRewardService = _ts_decorate4([
-  creatableService(),
+XyoBlockRewardService = _ts_decorate6([
+  creatable6(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     typeof Partial === "undefined" ? Object : Partial
@@ -487,24 +571,22 @@ XyoBlockRewardService = _ts_decorate4([
 
 // src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
 import { assertEx as assertEx6 } from "@xylabs/assert";
-import { isDefined as isDefined2, isNull } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { isDefined as isDefined3, isNull } from "@xylabs/typeof";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 import { asBlockBoundWitness as asBlockBoundWitness2, isBlockBoundWitness } from "@xyo-network/xl1-protocol";
-import { LRUCache } from "lru-cache";
+import { LRUCache as LRUCache2 } from "lru-cache";
 var ChainBlockNumberIterationService = class extends BaseService {
   static {
     __name(this, "ChainBlockNumberIterationService");
   }
-  _blocksByBlockNumber = new LRUCache({
+  _blocksByBlockNumber = new LRUCache2({
     max: 1e4
   });
   get chainArchivist() {
     return assertEx6(this.params.chainArchivist);
   }
-  get chainIdentification() {
-    return {
-      id: assertEx6(this.params.head?.chain)
-    };
+  get chainId() {
+    return assertEx6(this.params.head?.chain);
   }
   async get(block) {
     const head = await this.head();
@@ -512,11 +594,11 @@ var ChainBlockNumberIterationService = class extends BaseService {
     const cached = this._blocksByBlockNumber.get(block);
     if (cached) return cached;
     const startingBlock = head;
-    const currentBlockHash = await PayloadBuilder3.hash(startingBlock);
+    const currentBlockHash = await PayloadBuilder4.hash(startingBlock);
     let currentBlock = (await this.chainArchivist.get([
       currentBlockHash
     ])).at(0);
-    while (isDefined2(currentBlock)) {
+    while (isDefined3(currentBlock)) {
       assertEx6(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
       if (isBlockBoundWitness(currentBlock)) {
         this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
@@ -544,7 +626,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 = isDefined2(block) ? await this.get(block) : await this.head();
+    let currentBlock = isDefined3(block) ? await this.get(block) : await this.head();
     while (currentBlock && results.length < count) {
       if (isBlockBoundWitness(currentBlock)) {
         results.push(currentBlock);
@@ -555,7 +637,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
         ]);
         currentBlock = asBlockBoundWitness2(nextBlock[0]);
       } else {
-        const hash = PayloadBuilder3.hash(currentBlock);
+        const hash = PayloadBuilder4.hash(currentBlock);
         assertEx6(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
       }
     }
@@ -574,13 +656,14 @@ var ChainBlockNumberIterationService = class extends BaseService {
 
 // src/ChainValidator/XyoValidator.ts
 import { assertEx as assertEx7 } from "@xylabs/assert";
-function _ts_decorate5(decorators, target, key, desc) {
+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_decorate5, "_ts_decorate");
+__name(_ts_decorate7, "_ts_decorate");
 var XyoValidator = class extends BaseService {
   static {
     __name(this, "XyoValidator");
@@ -595,7 +678,7 @@ var XyoValidator = class extends BaseService {
     return assertEx7(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainInfo() {
-    return assertEx7(this.params.chainInformation, () => "chainInfo is required");
+    return assertEx7(this.params.chainId, () => "chainInfo is required");
   }
   get electionService() {
     return assertEx7(this.params.electionService, () => "electionService is required");
@@ -618,32 +701,26 @@ var XyoValidator = class extends BaseService {
     return await Promise.resolve(true);
   }
 };
-XyoValidator = _ts_decorate5([
-  creatableService()
+XyoValidator = _ts_decorate7([
+  creatable7()
 ], XyoValidator);
 
 // src/Election/XyoElectionService.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 PayloadBuilder4 } from "@xyo-network/payload-builder";
-function _ts_decorate6(decorators, target, key, desc) {
+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_decorate6, "_ts_decorate");
-function _ts_metadata2(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata2, "_ts_metadata");
+__name(_ts_decorate8, "_ts_decorate");
 var XyoElectionService = class extends BaseService {
   static {
     __name(this, "XyoElectionService");
   }
-  constructor(params) {
-    super(params);
-  }
   get chainIterator() {
     return assertEx8(this.params.chainIterator, () => "No chain iterator");
   }
@@ -657,7 +734,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 PayloadBuilder4.hash(current);
+      const previousBlockHash = await PayloadBuilder5.hash(current);
       return this.generateCreatorCommittee(candidates, previousBlockHash);
     });
   }
@@ -668,32 +745,30 @@ var XyoElectionService = class extends BaseService {
     return creatorArray.slice(0, maxSize);
   }
 };
-XyoElectionService = _ts_decorate6([
-  creatableService(),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    typeof XyoElectionServicesParams === "undefined" ? Object : XyoElectionServicesParams
-  ])
+XyoElectionService = _ts_decorate8([
+  creatable8()
 ], XyoElectionService);
 
 // src/PendingTransactions/PendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
-import { filterAsync } from "@xylabs/array";
+import { filterAs, filterAsync } from "@xylabs/array";
 import { assertEx as assertEx9 } from "@xylabs/assert";
-import { exists as exists2 } from "@xylabs/exists";
+import { creatable as creatable9 } from "@xylabs/creatable";
+import { exists as exists3 } from "@xylabs/exists";
 import { forget } from "@xylabs/forget";
+import { isDefined as isDefined4, isUndefined } from "@xylabs/typeof";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
+import { findMostRecentBlock } from "@xyo-network/chain-protocol";
 import { globalAttributes } from "@xyo-network/chain-telemetry";
 import { validateTransaction } from "@xyo-network/chain-validation";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
-import { asTransactionBoundWitnessWithStorageMeta as asTransactionBoundWitnessWithStorageMeta2, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { asBlockBoundWitnessWithHashStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 import { Mutex as Mutex2 } from "async-mutex";
 
 // src/PendingTransactions/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withStorageMeta = await PayloadBuilder5.addStorageMeta(payload.payloads);
+  const withStorageMeta = await PayloadBuilder6.addStorageMeta(payload.payloads);
   const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
@@ -704,7 +779,7 @@ var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload)
 }, "bundledPayloadToHydratedTransaction");
 
 // src/PendingTransactions/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder7 } 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) => {
@@ -712,8 +787,8 @@ var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) =>
   return bundle(root, transaction);
 }, "hydratedTransactionToPayloadBundle");
 var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder6.omitStorageMeta(p));
-  return new PayloadBuilder6({
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder7.omitStorageMeta(p));
+  return new PayloadBuilder7({
     schema: PayloadBundleSchema
   }).fields({
     payloads,
@@ -722,13 +797,13 @@ var bundle = /* @__PURE__ */ __name((root, transaction) => {
 }, "bundle");
 
 // src/PendingTransactions/PendingTransactions.ts
-function _ts_decorate7(decorators, target, key, desc) {
+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_decorate7, "_ts_decorate");
+__name(_ts_decorate9, "_ts_decorate");
 globalAttributes.setAttribute("XyoPendingTransactionsService:status", "unknown");
 var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends BaseService {
   static {
@@ -744,13 +819,9 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
     */
     ReadTransactions: 3,
     /**
-    * Priority for removing rejected transactions
+    * Priority for removing finalized/expired/rejected transactions
     */
-    RemoveRejectedTransactions: 2,
-    /**
-    * Priority for removing finalized transactions
-    */
-    RemoveFinalizedTransactions: 1
+    PurgeTransactions: 1
   };
   /**
   * A mutex to ensure that the counting the number of pending transactions is
@@ -780,8 +851,8 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
   get chainArchivist() {
     return assertEx9(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
-  get chainIdentification() {
-    return assertEx9(this.params.chainIdentification, () => "No chain id");
+  get chainId() {
+    return assertEx9(this.params.chainId, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
     return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
@@ -801,14 +872,16 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
     this._curatedPendingBundledTransactionsArchivist = await MemoryArchivist.create({
       account: "random"
     });
-    this.pendingBundledTransactionsArchivist.on("inserted", async ({ payloads }) => {
-      await this.insertNewTransactions(payloads);
+    this.pendingBundledTransactionsArchivist.on("inserted", ({ payloads }) => {
+      forget(this.insertNewTransactions(payloads));
     });
     this.chainArchivist.on("inserted", ({ payloads }) => {
       this.markAnyIncludedTransactionsForRemoval(payloads);
+      forget(this.cleanupWorker());
     });
     this.rejectedTransactionsArchivist.on("inserted", ({ payloads }) => {
       this.markAnyIncludedTransactionsForRemoval(payloads);
+      forget(this.cleanupWorker());
     });
     const pendingTransactionsCounter = this.meter?.createObservableUpDownCounter("xyo_pending_transactions_counter", {
       description: "The current number of pending transactions",
@@ -823,32 +896,25 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
   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);
+        if (isUndefined(lastHead)) return [];
+        await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
         const foundPendingTransactions = [];
-        const foundPendingTransactionsToDeleteHashes = [];
         let cursor;
         while (foundPendingTransactions.length < limit) {
-          const payloads = await this.pendingBundledTransactionsLocalArchivist.next({
+          const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
             limit: 100,
             order: "asc",
             cursor
           });
-          if (payloads.length === 0) break;
-          cursor = payloads.at(-1)?._sequence;
-          const deletedTransactionBundles = payloads.filter((tx) => this._removablePendingTransactionHashes.has(tx.root));
-          foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists2));
-          const undeletedTransactionBundles = payloads.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-          const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
-          foundPendingTransactions.push(...transactions);
-        }
-        await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes);
-        for (const hash of foundPendingTransactionsToDeleteHashes) {
-          this._removablePendingTransactionHashes.delete(hash);
-        }
-        if (foundPendingTransactionsToDeleteHashes.length > 0) {
-          this.logger?.log(`foundPendingTransactionsToDeleteHashes: Found ${foundPendingTransactionsToDeleteHashes.length} deletable transactions`);
-          for (const hash of foundPendingTransactionsToDeleteHashes) {
-            this.logger?.log(hash);
-          }
+          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(exists3);
+          const activeTransactions = transactions.filter(isTransactionActive(lastHead.block + 1));
+          foundPendingTransactions.push(...activeTransactions);
         }
         if (foundPendingTransactions.length > 0) {
           this.logger?.log(`getPendingTransactions: Found ${foundPendingTransactions.length} pending transactions`);
@@ -860,6 +926,12 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
       }, _XyoPendingTransactionsService.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);
+  }
   async countPendingTransactions() {
     if (this._countPendingTransactionsMutex.isLocked()) return;
     await this._countPendingTransactionsMutex.runExclusive(async () => {
@@ -881,9 +953,9 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
         const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
         const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map(async (tx) => {
           return await bundledPayloadToHydratedTransaction(tx);
-        }))).filter(exists2);
+        }))).filter(exists3);
         const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
-          const errors = await validateTransaction(tx, this.chainIdentification.id);
+          const errors = await validateTransaction(tx, this.chainId);
           if (errors.length > 0) {
             this.logger?.warn("validateTransaction", errors);
           }
@@ -908,39 +980,69 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
       this._removablePendingTransactionHashes.add(hash);
     }
   }
-  async removeBundledTransactions(bundledPayloads, priority) {
-    return await this.spanAsync(priority, async () => {
-      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        const bundledTransactions = (await Promise.all(bundledPayloads.map(async (payload) => {
-          const withStorageMeta = await PayloadBuilder7.addStorageMeta(payload.payloads);
-          const tx = asTransactionBoundWitnessWithStorageMeta2(withStorageMeta.find((p) => p._hash === payload.root));
-          return tx !== void 0 && payload._hash !== void 0 ? tx : void 0;
-        }))).filter(exists2);
-        await this.pendingBundledTransactionsLocalArchivist.delete(bundledTransactions.map((btx) => btx._hash));
-      }, _XyoPendingTransactionsService.MutexPriority[priority]);
+  async pruneCuratedPendingTransactionsArchivist(head) {
+    return await this.spanAsync("pruneCuratedPendingTransactionsArchivist", async () => {
+      const foundPendingTransactionsToDeleteHashes = [];
+      let cursor;
+      let [lastHead] = filterAs(await this.chainArchivist.get([
+        head
+      ]), asBlockBoundWitnessWithHashStorageMeta);
+      while (isDefined4(lastHead)) {
+        const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
+          limit: 100,
+          order: "asc",
+          cursor
+        });
+        if (pendingBundledTransactions.length === 0) {
+          break;
+        }
+        cursor = pendingBundledTransactions.at(-1)?._sequence;
+        const deletedTransactionBundles = pendingBundledTransactions.filter((tx) => this._removablePendingTransactionHashes.has(tx.root));
+        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(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(exists3);
+        foundPendingTransactionsToDeleteHashes.push(...expiredBundleHashes);
+      }
+      const deletedHashes = await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes);
+      for (const payload of deletedHashes) {
+        this._removablePendingTransactionHashes.delete(payload._hash);
+      }
+      if (deletedHashes.length > 0) {
+        this.logger?.log(`foundPendingTransactionsToDeleteHashes: Found ${deletedHashes.length} deletable transactions`);
+        for (const payload of deletedHashes) {
+          this.logger?.log(payload._hash);
+        }
+      }
     });
   }
 };
-XyoPendingTransactionsService = _ts_decorate7([
-  creatableService()
+XyoPendingTransactionsService = _ts_decorate9([
+  creatable9()
 ], XyoPendingTransactionsService);
+var isTransactionExpired = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.exp < block, "isTransactionExpired");
+var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block, "isTransactionActive");
 
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
-import { filterAs } from "@xylabs/array";
-import { exists as exists3 } from "@xylabs/exists";
+import { filterAs as filterAs2 } from "@xylabs/array";
+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 as ChainStakeIntentSchema2 } from "@xyo-network/xl1-protocol";
+import { asChainStakeIntent, ChainStakeIntentSchema } from "@xyo-network/xl1-protocol";
 var getBlockSignedStakeDeclarations = /* @__PURE__ */ __name(async (block, archivist, intent) => {
   const blockData = await archivist.get(block.payload_hashes);
-  const bwsFromBlock = filterAs(blockData, asOptionalBoundWitness);
-  const bwsFromBlockWithDeclarations = bwsFromBlock.filter((bw) => payloadSchemasContains(bw, ChainStakeIntentSchema2));
+  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(exists3);
+    const stakeIntentHashes = validBlockBwsWithDeclarations.flatMap(mapBoundWitnessToStakeIntentHashes).filter(exists4);
     const payloads = await archivist.get(stakeIntentHashes);
-    const stakeIntents = filterAs(payloads, asChainStakeIntent).filter((p) => p.intent === intent).filter((p) => bw.addresses.includes(p.from));
+    const stakeIntents = filterAs2(payloads, asChainStakeIntent).filter((p) => p.intent === intent).filter((p) => bw.addresses.includes(p.from));
     return stakeIntents;
   }))).flat();
 }, "getBlockSignedStakeDeclarations");
@@ -949,30 +1051,28 @@ var filterToValidSignedBoundWitnesses = /* @__PURE__ */ __name(async (bws) => {
   return bws.filter((_, index) => validBwIndexes[index]);
 }, "filterToValidSignedBoundWitnesses");
 var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
-  return bw.payload_schemas.map((schema, index) => schema === ChainStakeIntentSchema2 ? bw.payload_hashes[index] : void 0);
+  return bw.payload_schemas.map((schema, index) => schema === ChainStakeIntentSchema ? bw.payload_hashes[index] : void 0);
 }, "mapBoundWitnessToStakeIntentHashes");
 
 // src/StakeIntent/XyoStakeIntentService.ts
-import { filterAs as filterAs2 } from "@xylabs/array";
+import { filterAs as filterAs3 } from "@xylabs/array";
 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 { 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 { Mutex as Mutex3 } from "async-mutex";
-import { LRUCache as LRUCache2 } from "lru-cache";
-function _ts_decorate8(decorators, target, key, desc) {
+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_decorate8, "_ts_decorate");
-function _ts_metadata3(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata3, "_ts_metadata");
+__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;
@@ -990,16 +1090,10 @@ 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 LRUCache2({
+  _stakeCache = new LRUCache3({
     max: STAKE_CACHE_MAX_ENTRIES
   });
   _updateMutex = new Mutex3();
-  constructor(params) {
-    super(params);
-    this.chainIterator.on("headUpdated", async () => {
-      await this.updateIndex();
-    });
-  }
   get chainArchivist() {
     return assertEx10(this.params.chainArchivist, () => "chainArchivist not set");
   }
@@ -1013,11 +1107,13 @@ var XyoStakeIntentService = class extends BaseService {
     return assertEx10(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
+    this.chainIterator.on("headUpdated", async () => {
+      await this.updateIndex();
+    });
     const head = await this.chainIterator.head();
+    if (isUndefined2(head)) return;
     const headHash = await PayloadBuilder8.hash(head);
-    if (head?.block === void 0) return;
     await this.recoverState(headHash);
-    await this.updateIndex(true);
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
@@ -1032,15 +1128,27 @@ var XyoStakeIntentService = class extends BaseService {
       const candidates = [
         ...results
       ];
-      const validCandidates = await this.filterToValidStake(candidates, this.chainStakeViewer);
+      const requiredMinimumStake = this.getRequiredMinimumStakeForIntent(intent);
+      const validCandidates = await this.filterToValidStake(candidates, this.chainStakeViewer, requiredMinimumStake);
       return validCandidates;
     });
   }
+  getRequiredMinimumStakeForIntent(intent) {
+    switch (intent) {
+      case "producer": {
+        const requiredMinimumStake = isDefined5(process.env.XYO_PRODUCER_MIN_STAKE) ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE) : 1n;
+        return requiredMinimumStake;
+      }
+    }
+  }
   async isStakedForBlock(block, intent, address) {
     const candidates = await this.getDeclaredCandidatesForBlock(block, intent);
     return candidates.includes(address);
   }
-  async filterToValidStake(candidates, chainStakeViewer, requiredMinimumStake = 1n) {
+  async startHandler() {
+    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) {
@@ -1120,11 +1228,12 @@ var XyoStakeIntentService = class extends BaseService {
     await this._updateMutex.runExclusive(async () => {
       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, [
           new ChainStakeIntentAnalyzer("producer")
         ], currentHeadHash, this._lastIndexedBlockHash);
-        const signedDeclarations = filterAs2(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
+        const signedDeclarations = filterAs3(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
         if (currentHead.block === void 0) return;
         const currentHeadBlockNum = currentHead.block;
         if (displayProgress) this.logger?.info(`Updating index through 0x${currentHeadBlockNum}`);
@@ -1142,12 +1251,8 @@ var XyoStakeIntentService = class extends BaseService {
     });
   }
 };
-XyoStakeIntentService = _ts_decorate8([
-  creatableService(),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
-    typeof XyoStakeIntentServiceParams === "undefined" ? Object : XyoStakeIntentServiceParams
-  ])
+XyoStakeIntentService = _ts_decorate10([
+  creatable10()
 ], XyoStakeIntentService);
 
 // src/Staker/Evm/Evm.ts
@@ -1160,15 +1265,15 @@ 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.id), this.params.runner);
+      this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(this.chainId), this.params.runner);
     }
     return assertEx11(this.params.contract);
   }
-  get id() {
-    return assertEx11(this.params.id);
-  }
   get runner() {
     return assertEx11(this.params.runner);
   }
@@ -1186,9 +1291,6 @@ var EvmChainService = class extends BaseService {
     await result.wait();
     return true;
   }
-  async chainId() {
-    return toAddress(await this.contract.chainId());
-  }
   async forkedAtBlockNumber() {
     return await this.contract.forkedAtBlockNumber();
   }
@@ -1230,15 +1332,81 @@ var EvmChainService = class extends BaseService {
     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 {
   BaseAccountableService,
   BaseService,
+  ChainAccountBalanceServiceV2,
   ChainBlockNumberIterationService,
   DEFAULT_BLOCK_SIZE,
   EvmBlockRewardService,
   EvmChainService,
-  XYO_PRODUCER_RESTAKE_DURATION,
-  XYO_PRODUCER_RESTAKE_WINDOW,
+  MemoryChainService,
+  XYO_PRODUCER_REDECLARATION_DURATION,
+  XYO_PRODUCER_REDECLARATION_WINDOW,
   XyoBlockProducer,
   XyoBlockRewardService,
   XyoChainAccountBalanceService,
@@ -1247,6 +1415,7 @@ export {
   XyoStakeIntentService,
   XyoValidator,
   accountBalanceServiceFromArchivist,
+  accountBalanceServiceFromArchivistV2,
   creatableService,
   getBlockSignedStakeDeclarations
 };