@xyo-network/chain-services 1.16.26 → 1.17.1

package/dist/neutral/index.mjs

@@ -2,22 +2,66 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
-import { findMostRecentBlock } from "@xyo-network/chain-protocol";
+import { assertEx } from "@xylabs/sdk-js";
 import { StepSizes } from "@xyo-network/xl1-protocol";
-import { LruCacheMap, readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
+import { findMostRecentBlock, LruCacheMap, readPayloadMapFromStore, SimpleAccountBalanceViewer, SimpleBlockViewer } from "@xyo-network/xl1-protocol-sdk";
 import { Semaphore } from "async-mutex";
-
-// src/AccountBalance/BaseAccountBalanceService.ts
-import { assertEx, creatable as creatable2 } from "@xylabs/sdk-js";
-import { spanRootAsync as spanRootAsync2 } from "@xylabs/telemetry";
-import { AttoXL1 } from "@xyo-network/xl1-protocol";
-import { balancesSummary, SimpleAccountBalanceViewer } from "@xyo-network/xl1-protocol-sdk";
-import z from "zod";
+var accountBalancesViewerFromArchivist = /* @__PURE__ */ __name(async (chainId, archivist) => {
+  const summaryMap = new LruCacheMap({
+    max: 1e5,
+    allowStale: true,
+    noDisposeOnSet: false,
+    updateAgeOnGet: true
+  });
+  const transferSummaryMap = new LruCacheMap({
+    max: 1e5,
+    allowStale: true,
+    noDisposeOnSet: false,
+    updateAgeOnGet: true
+  });
+  const chainMap = readPayloadMapFromStore(archivist);
+  const headFunc = /* @__PURE__ */ __name(async () => {
+    const head = assertEx(await findMostRecentBlock(archivist), () => "No blocks found in chainArchivist");
+    return [
+      head._hash,
+      head.block
+    ];
+  }, "headFunc");
+  const service = await SimpleAccountBalanceViewer.create({
+    context: {
+      chainId,
+      store: {
+        chainMap
+      },
+      stepSemaphores: StepSizes.map(() => new Semaphore(20)),
+      summaryMap,
+      head: headFunc
+    },
+    transfersSummaryContext: {
+      chainId,
+      store: {
+        chainMap
+      },
+      stepSemaphores: StepSizes.map(() => new Semaphore(20)),
+      summaryMap: transferSummaryMap,
+      head: headFunc
+    },
+    blockViewer: await SimpleBlockViewer.create({
+      context: {
+        chainId,
+        head: headFunc,
+        store: {
+          chainMap
+        }
+      },
+      finalizedArchivist: archivist
+    })
+  });
+  return service;
+}, "accountBalancesViewerFromArchivist");
 
 // src/BaseService.ts
 import { AbstractCreatable, creatable } from "@xylabs/sdk-js";
-import { spanRoot, spanRootAsync } 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;
@@ -40,15 +84,6 @@ var BaseService = class extends AbstractCreatable {
       return await this.create(params);
     });
   }
-  paramsHandler(params) {
-    return params;
-  }
-  span(name, fn) {
-    return spanRoot(name, fn, this.tracer);
-  }
-  async spanAsync(name, fn) {
-    return await spanRootAsync(name, fn, this.tracer);
-  }
 };
 BaseService = _ts_decorate([
   creatable()
@@ -65,7 +100,10 @@ function creatableService() {
 }
 __name(creatableService, "creatableService");
 
-// src/AccountBalance/BaseAccountBalanceService.ts
+// src/BlockReward/EvmBlockRewardViewer.ts
+import { AbstractCreatable as AbstractCreatable2, assertEx as assertEx2, creatable as creatable2, toEthAddress } from "@xylabs/sdk-js";
+import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
+import { asAttoXL1 } from "@xyo-network/xl1-protocol";
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -73,804 +111,358 @@ function _ts_decorate2(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate2, "_ts_decorate");
-var BaseAccountBalanceServiceParamsZod = z.object({
-  blockViewer: z.object().loose(),
-  chainArchivist: z.object().loose(),
-  chainIterator: z.object().loose(),
-  context: z.object().loose(),
-  transferContext: z.object().loose()
-});
-var BaseAccountBalanceService = class extends BaseService {
+var EvmBlockRewardViewer = class extends AbstractCreatable2 {
   static {
-    __name(this, "BaseAccountBalanceService");
-  }
-  accountBalanceViewer;
-  get blockViewer() {
-    return assertEx(this.params.blockViewer, () => "BlockViewer has not been initialized yet");
-  }
-  static async paramsHandler(params) {
-    BaseAccountBalanceServiceParamsZod.parse(params);
-    assertEx(params?.context?.head, () => "BalanceStepSummaryContext is required in BaseAccountBalanceServiceParams");
-    return {
-      ...await super.paramsHandler(params),
-      ...params
-    };
+    __name(this, "EvmBlockRewardViewer");
   }
-  async accountBalance(address, headOrRange) {
-    const balances = await this.accountsBalances([
-      address
-    ], headOrRange);
-    return balances[address] ?? AttoXL1(0n);
+  _contractAddress;
+  get chainContractViewer() {
+    return assertEx2(this.params.chainContractViewer, () => "chainContractViewer is required");
   }
-  accountBalanceHistory(_address, _headOrRange) {
-    throw new Error("Method not implemented.");
+  get contractAddress() {
+    return assertEx2(this._contractAddress, () => "contractAddress is required");
   }
-  async accountsBalances(address, _headOrRange) {
-    return await spanRootAsync2("balances", async () => {
-      const context = {
-        head: this.params.context.head,
-        stepSemaphores: this.params.context.stepSemaphores,
-        store: this.params.context.store,
-        chainId: this.params.context.chainId,
-        summaryMap: this.params.context.summaryMap
-      };
-      const summary = await balancesSummary(context);
-      const result = {};
-      for (const addr of address) {
-        const summaryBalance = summary[addr] ?? 0n;
-        result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance);
-      }
-      return result;
-    });
+  get provider() {
+    return assertEx2(this.params.provider, () => "provider is required");
   }
-  accountsBalancesHistory(_addresses, _headOrRange) {
-    throw new Error("Method not implemented.");
+  async allowedRewardForBlock(blockNumber) {
+    const contract = XyoChainRewardsFactory.connect(toEthAddress(this.contractAddress), this.provider);
+    return asAttoXL1(await contract.calcBlockReward(blockNumber));
   }
   async createHandler() {
-    this.accountBalanceViewer = await SimpleAccountBalanceViewer.create({
-      context: this.params.context,
-      transferContext: this.params.transferContext,
-      blockViewer: this.blockViewer
-    });
+    await super.createHandler();
+    try {
+      this._contractAddress = await this.chainContractViewer.rewardsContract();
+    } catch (ex) {
+      const error = ex;
+      throw new Error(`Failed to get rewards contract address: ${error.message}`);
+    }
   }
 };
-BaseAccountBalanceService = _ts_decorate2([
+EvmBlockRewardViewer = _ts_decorate2([
   creatable2()
-], BaseAccountBalanceService);
-
-// src/AccountBalance/accountBalanceServiceFromArchivist.ts
-var accountBalancesServiceFromArchivist = /* @__PURE__ */ __name(async (chainId, archivist) => {
-  const summaryMap = new LruCacheMap({
-    max: 1e5,
-    allowStale: true,
-    noDisposeOnSet: false,
-    updateAgeOnGet: true
-  });
-  const chainMap = readPayloadMapFromStore(archivist);
-  const headFunc = /* @__PURE__ */ __name(async () => {
-    const head = await findMostRecentBlock(archivist);
-    return [
-      assertEx2(head?._hash, () => "No head found in chainArchivist"),
-      assertEx2(head?.block, () => "No head found in chainArchivist")
-    ];
-  }, "headFunc");
-  const service = await BaseAccountBalanceService.create({
-    context: {
-      chainId,
-      store: {
-        chainMap
-      },
-      stepSemaphores: StepSizes.map(() => new Semaphore(20)),
-      summaryMap,
-      head: headFunc
-    }
-  });
-  return service;
-}, "accountBalancesServiceFromArchivist");
+], EvmBlockRewardViewer);
 
-// src/AccountTransfers/BaseAccountTransfersService.ts
-import { creatable as creatable3 } from "@xylabs/sdk-js";
-import { spanRootAsync as spanRootAsync3 } from "@xylabs/telemetry";
-import { AttoXL1 as AttoXL12 } from "@xyo-network/xl1-protocol";
-import { transfersSummary } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate3(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate3, "_ts_decorate");
-var BaseAccountTransfersService = class extends BaseService {
-  static {
-    __name(this, "BaseAccountTransfersService");
-  }
-  async transfer(head, address) {
-    return (await this.transfers(head, [
-      address
-    ]))[address] ?? AttoXL12(0n);
-  }
-  async transfers(head, addresses) {
-    return await spanRootAsync3("transfers", async () => {
-      const summary = await transfersSummary(this.params.context);
-      const result = {};
-      for (const addr of addresses) {
-        const summaryBalance = summary[addr] ?? 0n;
-        result[addr] = AttoXL12(summaryBalance);
+// src/blockViewerFromChainIteratorAndArchivist.ts
+import { isDefined } from "@xylabs/sdk-js";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { asSignedBlockBoundWitness, asSignedBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+function blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist) {
+  const result = {
+    blockByHash: /* @__PURE__ */ __name(async function(hash) {
+      const [payload] = await chainArchivist.get([
+        hash
+      ]);
+      const block = asSignedBlockBoundWitnessWithStorageMeta(payload);
+      if (isDefined(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes);
+        return [
+          block,
+          payloads
+        ];
       }
-      return result;
-    });
-  }
-};
-BaseAccountTransfersService = _ts_decorate3([
-  creatable3()
-], BaseAccountTransfersService);
+      return null;
+    }, "blockByHash"),
+    blockByNumber: /* @__PURE__ */ __name(async function(blockNumber) {
+      const payload = asSignedBlockBoundWitness(await chainIterator.get(blockNumber));
+      const block = payload ? await PayloadBuilder.addHashMeta(payload) : void 0;
+      if (isDefined(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes);
+        return [
+          block,
+          payloads
+        ];
+      }
+      return null;
+    }, "blockByNumber"),
+    blocksByHash: /* @__PURE__ */ __name(async function(hash, limit = 10) {
+      const results = [];
+      for (let i = 0; i < limit; i++) {
+        const block = await this.blockByHash(hash);
+        if (block) {
+          results.push(block);
+        } else {
+          break;
+        }
+      }
+      return results;
+    }, "blocksByHash"),
+    blocksByNumber: /* @__PURE__ */ __name(async function(number, limit = 10) {
+      const results = [];
+      for (let i = 0; i < limit; i++) {
+        const block = await this.blockByNumber(number);
+        if (block) {
+          results.push(block);
+        } else {
+          break;
+        }
+      }
+      return results;
+    }, "blocksByNumber"),
+    currentBlock: /* @__PURE__ */ __name(async function() {
+      const head = await chainIterator.head();
+      return this.blockByHash(head._hash);
+    }, "currentBlock"),
+    currentBlockHash: /* @__PURE__ */ __name(async function() {
+      const head = await chainIterator.head();
+      return head._hash;
+    }, "currentBlockHash"),
+    currentBlockNumber: /* @__PURE__ */ __name(async function() {
+      const head = await chainIterator.head();
+      return head.block;
+    }, "currentBlockNumber"),
+    payloadByHash: /* @__PURE__ */ __name(function(_hash) {
+      throw new Error("Function not implemented.");
+    }, "payloadByHash"),
+    payloadsByHash: /* @__PURE__ */ __name(function(_hashes) {
+      throw new Error("Function not implemented.");
+    }, "payloadsByHash")
+  };
+  return result;
+}
+__name(blockViewerFromChainIteratorAndArchivist, "blockViewerFromChainIteratorAndArchivist");
 
-// src/BlockProducer/BaseBlockProducerService.ts
-import { AddressZod, asHash, assertEx as assertEx4, creatable as creatable4, exists, hexToBigInt, isDefined, toHex } from "@xylabs/sdk-js";
-import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
-import { buildNextBlock, createDeclarationIntent } from "@xyo-network/chain-protocol";
+// src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
+import { assertEx as assertEx3, isDefined as isDefined2, isNull, isUndefined } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness, AttoXL1 as AttoXL13, BlockNumberSchema, defaultRewardRatio, TimeSchema, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
-import z2 from "zod";
-
-// src/BlockProducer/generateTransactionFeeTransfers.ts
-import { hexFromBigInt } from "@xylabs/sdk-js";
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { TransferSchema, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-protocol";
-import { transactionRequiredGas } from "@xyo-network/xl1-protocol-sdk";
-import { HydratedTransactionWrapper } from "@xyo-network/xl1-wrappers";
-async function generateTransactionFeeTransfers(address, transactions) {
-  const txs = await Promise.all(transactions.map(async (tx) => {
-    return HydratedTransactionWrapper.parse([
-      await PayloadBuilder.addStorageMeta(tx[0]),
-      await PayloadBuilder.addStorageMeta(tx[1])
-    ]);
-  }));
-  const txBaseFeeCosts = {};
-  for (const tx of txs) {
-    txBaseFeeCosts[tx.boundWitness.from] = (txBaseFeeCosts[tx.boundWitness.from] ?? 0n) + tx.fees.base;
+import { asBlockBoundWitness, asBlockBoundWitnessWithStorageMeta, asSignedHydratedBlockWithHashMeta, asXL1BlockNumber, isBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
+import { hydrateBlock } from "@xyo-network/xl1-protocol-sdk";
+import { LRUCache } from "lru-cache";
+var ChainBlockNumberIterationService = class extends BaseService {
+  static {
+    __name(this, "ChainBlockNumberIterationService");
   }
-  const txGasCosts = {};
-  for (const tx of txs) {
-    const requiredGas = transactionRequiredGas(tx.data);
-    const totalGasCost = requiredGas * tx.fees.gasPrice;
-    txGasCosts[tx.boundWitness.from] = (txBaseFeeCosts[tx.boundWitness.from] ?? 0n) + totalGasCost;
+  _blocksByBlockNumber = new LRUCache({
+    max: 1e4
+  });
+  _currentHead;
+  get chainId() {
+    return assertEx3(this._currentHead?.chain ?? this.params?.head?.chain, () => "Current head is not set");
   }
-  const payloads = Object.entries(txBaseFeeCosts).map(([from, amount]) => {
-    const payload = {
-      schema: TransferSchema,
-      epoch: Date.now(),
-      from,
-      transfers: {
-        // burn the base fee
-        [XYO_ZERO_ADDRESS]: hexFromBigInt(amount)
-      }
+  get chainMap() {
+    return assertEx3(this.params.chainMap);
+  }
+  get chainStoreRead() {
+    return {
+      chainMap: this.chainMap
     };
-    return payload;
-  });
-  for (const [from, amount] of Object.entries(txGasCosts)) {
-    const fromPayload = assertEx3(payloads.find((p) => p.from === from), () => "from payload not found");
-    fromPayload.transfers[address] = hexFromBigInt(amount);
   }
-  return payloads;
-}
-__name(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
-
-// src/BlockProducer/BaseBlockProducerService.ts
-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 DEFAULT_BLOCK_SIZE = 10;
-var XYO_PRODUCER_REDECLARATION_DURATION = 1e4;
-var XYO_PRODUCER_REDECLARATION_WINDOW = 500;
-var BaseBlockProducerServiceParamsZod = z2.object({
-  balanceService: z2.object().loose(),
-  pendingTransactionsService: z2.object().loose(),
-  rejectedTransactionsArchivist: z2.object().loose(),
-  rewardAddress: AddressZod,
-  time: z2.object().loose()
-});
-var BaseBlockProducerService = class _BaseBlockProducerService extends BaseService {
-  static {
-    __name(this, "BaseBlockProducerService");
+  async blockByHash(hash) {
+    return asSignedHydratedBlockWithHashMeta(await hydrateBlock(this.chainStoreRead, hash)) ?? null;
   }
-  _blockRewardDiviner;
-  /**
-  * The default block size for a block
-  */
-  static get DefaultBlockSize() {
-    return DEFAULT_BLOCK_SIZE;
+  async blockByNumber(block) {
+    return asSignedHydratedBlockWithHashMeta(await this.get(block)) ?? null;
   }
-  /**
-  * The amount of time for which the producer will redeclare
-  * their intent to continue producing blocks
-  */
-  static get RedeclarationDuration() {
-    return XYO_PRODUCER_REDECLARATION_DURATION;
+  async blocksByHash(hash, limit = 100) {
+    const results = [];
+    let currentBlock = await this.blockByHash(hash);
+    while (currentBlock !== null && (isUndefined(limit) || results.length < limit)) {
+      results.push(currentBlock);
+      const previousHash = currentBlock[0].previous;
+      if (isNull(previousHash)) break;
+      currentBlock = await this.blockByHash(previousHash);
+    }
+    return results;
   }
-  /**
-  * The number of blocks within which the producer will redeclare
-  * their intent to continue producing blocks
-  */
-  static get RedeclarationWindow() {
-    return XYO_PRODUCER_REDECLARATION_WINDOW;
+  async blocksByNumber(blockNumber, limit = 100) {
+    const results = [];
+    let currentBlock = await this.blockByNumber(blockNumber);
+    while (currentBlock !== null && (isUndefined(limit) || results.length < limit)) {
+      results.push(currentBlock);
+      if (currentBlock[0].block === 0) break;
+      const previousNumber = asXL1BlockNumber(currentBlock[0].block - 1, true);
+      currentBlock = await this.blockByNumber(previousNumber);
+    }
+    return results;
   }
-  get address() {
-    return this.account.address;
+  async currentBlock() {
+    return assertEx3(await this.blockByHash(await this.currentBlockHash()), () => "Current block not found");
   }
-  get account() {
-    return assertEx4(this.params.account, () => "account is required");
+  async currentBlockHash() {
+    const head = assertEx3(await this.head(), () => "Head is not set");
+    return head._hash;
   }
-  get balanceService() {
-    return assertEx4(this.params.balanceService, () => "balanceService is required");
+  async currentBlockNumber() {
+    const head = assertEx3(await this.head(), () => "Head is not set");
+    return head.block;
   }
-  get chainArchivist() {
-    return assertEx4(this.params.chainArchivist, () => "chainArchivist is required");
+  async get(block) {
+    const head = await this.head();
+    assertEx3(head.block >= block, () => `Block requested is newer than the current head [${block}]`);
+    const cached = this._blocksByBlockNumber.get(block);
+    if (cached) return cached;
+    const startingBlock = head;
+    const currentBlockHash = await PayloadBuilder2.hash(startingBlock);
+    let currentBlock = await this.chainMap.get(currentBlockHash);
+    while (isDefined2(currentBlock)) {
+      assertEx3(asBlockBoundWitness(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
+      if (isBlockBoundWitnessWithHashMeta(currentBlock)) {
+        this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
+        if (currentBlock.block === block) {
+          return currentBlock;
+        }
+        const { previous } = currentBlock;
+        if (isNull(previous)) break;
+        currentBlock = await this.chainMap.get(previous);
+      }
+    }
+    throw new Error(`Block not found: ${block}`);
   }
-  get chainId() {
-    return assertEx4(this.params.chainId, () => "chainId is required");
+  async head() {
+    if (isDefined2(this._currentHead)) return this._currentHead;
+    if (isDefined2(this.params.head)) {
+      const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(this.params.head);
+      this._currentHead = newHead;
+      return newHead;
+    }
+    throw new Error("Head is not set");
   }
-  get electionService() {
-    return assertEx4(this.params.electionService, () => "electionService is required");
+  async next(block) {
+    const currentBlock = block;
+    const nextBlockNumber = currentBlock + 1;
+    return await this.get(nextBlockNumber);
   }
-  get pendingTransactionsService() {
-    return assertEx4(this.params.pendingTransactionsService, () => "Missing pendingTransactionsService");
+  payloadByHash(_hash) {
+    throw new Error("Method [payloadByHash] not implemented.");
   }
-  get rejectedTransactionsArchivist() {
-    return assertEx4(this.params.rejectedTransactionsArchivist, () => "No rejected bundled transactions archivist");
+  payloadsByHash(_hashes) {
+    throw new Error("Method [payloadsByHash] not implemented.");
   }
-  get rewardAddress() {
-    return assertEx4(this.params.rewardAddress, () => "No reward address provided");
+  // TODO: Decide on inclusive/exclusive (probably need inclusive to account for chain head)
+  // 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();
+    while (isDefined2(currentBlock) && results.length < count) {
+      if (isBlockBoundWitnessWithHashMeta(currentBlock)) {
+        results.push(currentBlock);
+        const { previous } = currentBlock;
+        if (isNull(previous)) break;
+        const nextBlock = await this.chainMap.get(previous);
+        currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock);
+      } else {
+        const hash = PayloadBuilder2.hash(currentBlock);
+        assertEx3(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
+      }
+    }
+    return results;
   }
-  get rewardService() {
-    return assertEx4(this.params.rewardService, () => "rewardService is required");
+  async updateHead(head) {
+    const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head);
+    this._currentHead = newHead;
+    void this.emit("headUpdated", {
+      blocks: [
+        newHead
+      ]
+    });
   }
-  get stakeIntentService() {
-    return assertEx4(this.params.stakeIntentService, () => "No StakeIntentService provided");
+  async getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head) {
+    const hash = await PayloadBuilder2.hash(head);
+    const stored = await this.chainMap.get(hash);
+    const newHead = asBlockBoundWitnessWithStorageMeta(stored);
+    if (isUndefined(newHead)) throw new Error(`Head block not found in archivist [${hash}]`);
+    return newHead;
   }
-  get time() {
-    return assertEx4(this.params.time, () => "No TimeSyncViewer provided");
+};
+
+// src/ChainService/Evm/Evm.ts
+import { assertEx as assertEx4, toAddress, toEthAddress as toEthAddress2 } from "@xylabs/sdk-js";
+import { StakedXyoChain__factory as StakedXyoChainFactory } from "@xyo-network/typechain";
+import { getAddress } from "ethers/address";
+var EvmChainService = class extends BaseService {
+  static {
+    __name(this, "EvmChainService");
   }
-  get validateHydratedBlockState() {
-    return assertEx4(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
+  async active() {
+    return await (await this.contract()).active();
   }
-  static async paramsHandler(params) {
-    BaseBlockProducerServiceParamsZod.parse(params);
-    return {
-      ...await super.paramsHandler(params),
-      ...params
-    };
+  async activeByStaked(staked) {
+    return await (await this.contract()).activeByAddressStaked(getAddress(toEthAddress2(staked)));
   }
-  async next(head) {
-    if (head.chain !== this.chainId) return;
-    const leadersStart = Date.now();
-    const leaders = await this.electionService.getCreatorCommitteeForNextBlock(head);
-    const leadersDuration = Date.now() - leadersStart;
-    if (leadersDuration > 100) {
-      this.logger?.warn(`[Slow] Fetched leaders in ${leadersDuration}ms: ${leaders.map((l) => l.slice(0, 6)).join(", ")}`);
-    }
-    if (!leaders.includes(this.address)) return;
-    return this.proposeNextValidBlock(head);
+  async activeByStaker(address) {
+    return await (await this.contract()).activeByStaker(getAddress(toEthAddress2(address)));
   }
-  async getBlockRewardTransfers(block) {
-    if (!this._blockRewardDiviner) {
-      this._blockRewardDiviner = await FixedPercentageBlockRewardDiviner.create({
-        account: "random",
-        blockRewardService: this.rewardService,
-        config: {
-          rewardAddress: this.rewardAddress,
-          rewardPercentageRatio: defaultRewardRatio,
-          schema: FixedPercentageBlockRewardDivinerConfigSchema
-        }
-      });
+  async addStake(staked, amount) {
+    const result = await (await this.contract()).addStake(getAddress(toEthAddress2(staked)), amount);
+    await result.wait();
+    return true;
+  }
+  chainId() {
+    return assertEx4(this.params.id);
+  }
+  async contract() {
+    if (this.params.contract === void 0) {
+      this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(await this.chainId()), this.params.runner);
     }
-    const blockHex = assertEx4(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
-    ]);
-    return rewards;
+    return assertEx4(this.params.contract);
   }
-  /**
-  * 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");
-    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 > _BaseBlockProducerService.RedeclarationWindow) return;
-    return createDeclarationIntent(this.address, "producer", currentBlock, currentBlock + _BaseBlockProducerService.RedeclarationDuration);
+  async forkedAtBlockNumber() {
+    return await (await this.contract()).forkedAtBlockNumber();
   }
-  async proposeNextValidBlock(head, validateBalances = false) {
-    return await this.spanAsync("proposeNextValidBlock", async () => {
-      const { block: previousBlock } = assertEx4(asBlockBoundWitness(head), () => "Invalid head block");
-      const nextBlock = previousBlock + 1;
-      const nextBlockTransactionsStart = Date.now();
-      const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, _BaseBlockProducerService.DefaultBlockSize);
-      const nextBlockTransactionsDuration = Date.now() - nextBlockTransactionsStart;
-      if (nextBlockTransactionsDuration > 200) {
-        this.logger?.warn(`[Slow] Fetched ${nextBlockTransactions.length} pending transactions in ${nextBlockTransactionsDuration}ms}`);
-      }
-      const blockPayloads = [];
-      const producerRedeclarationPayload = await this.getProducerRedeclaration(head);
-      if (producerRedeclarationPayload) blockPayloads.push(producerRedeclarationPayload);
-      if (blockPayloads.length === 0 && nextBlockTransactions.length === 0 && !this.heartbeatRequired(head)) return;
-      const rewardTransferPayloads = await this.getBlockRewardTransfers(nextBlock);
-      blockPayloads.push(...rewardTransferPayloads);
-      const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions);
-      const timeStart = Date.now();
-      const timePayload = await this.generateTimePayload(head);
-      const timeDuration = Date.now() - timeStart;
-      if (timeDuration > 100) {
-        this.logger?.warn(`[Slow] Generated time payload in ${timeDuration}ms`);
-      }
-      const [fundedNextBlockTransactions, fundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, validateBalances);
-      blockPayloads.push(...fundedTransfers, timePayload);
-      this.logger?.info(`Building block ${head.block + 1}`);
-      const startBuild = Date.now();
-      const stepRewardPoolBalance = (await this.balanceService.accountsBalances([
-        XYO_STEP_REWARD_ADDRESS
-      ]))[XYO_STEP_REWARD_ADDRESS];
-      const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [
-        this.account
-      ], XYO_STEP_REWARD_ADDRESS, stepRewardPoolBalance);
-      this.logger?.info(`Built block ${block[0].block} in ${Date.now() - startBuild}ms with ${block[1].length} payloads`);
-      this.logger?.info(`Validating block ${block[0].block} with ${block[1].length} payloads`);
-      const startValidate = Date.now();
-      const errors = await this.validateHydratedBlockState(block, this.chainId, {
-        accountBalance: this.balanceService
-      });
-      this.logger?.info(`Validated block ${block[0].block} in ${Date.now() - startValidate}ms with ${block[1].length} payloads`);
-      if (errors.length > 0) {
-        this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`);
-        const rejectedTransactions = block[1];
-        await this.rejectedTransactionsArchivist.insert(rejectedTransactions);
-      } else {
-        return block;
-      }
-    });
+  async forkedAtHash() {
+    return await (await this.contract()).forkedAtHash();
   }
-  // remove unfunded transactions and block transfers
-  async filterByFunded(head, txs, transfers, validateBalances = false) {
-    const fundedTransfers = [];
-    const fundedTransactions = (await Promise.all(txs.map(async (tx) => {
-      const transfer = transfers.find((transfer2) => transfer2.from === tx[0].from);
-      if (!transfer) return;
-      const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? "00"), 0n);
-      if (validateBalances) {
-        const balance = (await this.balanceService.accountsBalances([
-          transfer.from
-        ]))[transfer.from] ?? AttoXL13(0n);
-        if (balance >= totalTransferCost) {
-          fundedTransfers.push(transfer);
-          return tx;
-        }
-      } else {
-        fundedTransfers.push(transfer);
-        return tx;
-      }
-    }))).filter(exists);
-    return [
-      fundedTransactions,
-      fundedTransfers
-    ];
+  async forkedChainId() {
+    return toAddress(await (await this.contract()).forkedChainId());
   }
-  async generateTimePayload(head) {
-    const [ethereum, ethHashOrNull] = await this.time.currentTimeAndHash("ethereum");
-    const ethereumHash = asHash(ethHashOrNull, () => "No ethereum hash available from time sync service");
-    const timePayload = {
-      schema: TimeSchema,
-      // this is for the previous block
-      xl1: head.block,
-      // this is for the previous block
-      xl1Hash: head._hash,
-      ethereum,
-      ethereumHash,
-      epoch: Date.now()
-    };
-    return timePayload;
+  async minWithdrawalBlocks() {
+    return await (await this.contract()).minWithdrawalBlocks();
   }
-  /**
-  * Check if a heartbeat block is required based on network activity.
-  * @param head The current head block
-  * @returns True if a heartbeat is required, false otherwise
-  */
-  heartbeatRequired(head) {
-    const epoch = head.$epoch;
-    if (isDefined(epoch)) {
-      const { heartbeatInterval } = this.params.config.producer;
-      if (Date.now() - epoch > heartbeatInterval) {
-        return true;
-      }
-    }
-    return false;
+  async pending() {
+    return await (await this.contract()).pending();
   }
-};
-BaseBlockProducerService = _ts_decorate4([
-  creatable4()
-], BaseBlockProducerService);
-
-// src/BlockReward/BaseBlockRewardService.ts
-import { creatable as creatable5 } from "@xylabs/sdk-js";
-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 BaseBlockRewardService = class extends BaseService {
-  static {
-    __name(this, "BaseBlockRewardService");
+  async pendingByStaker(staker) {
+    return await (await this.contract()).pendingByStaker(getAddress(toEthAddress2(staker)));
   }
-  getRewardForBlock(_blockNumber) {
-    throw new Error("getRewardForBlock method must be implemented in derived classes");
+  async removeStake(slot) {
+    const result = await (await this.contract()).removeStake(slot);
+    await result.wait();
+    return true;
   }
-};
-BaseBlockRewardService = _ts_decorate5([
-  creatable5()
-], BaseBlockRewardService);
-
-// src/BlockReward/EvmBlockRewardService.ts
-import { assertEx as assertEx5, creatable as creatable6, toEthAddress } from "@xylabs/sdk-js";
-import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
-function _ts_decorate6(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  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 EvmBlockRewardService = class extends BaseBlockRewardService {
-  static {
-    __name(this, "EvmBlockRewardService");
+  rewardForBlock(_block) {
+    throw new Error("Method not implemented.");
   }
-  _contractAddress;
-  get chainService() {
-    return assertEx5(this.params.chainService, () => "chainService is required");
+  async rewardsContract() {
+    return await (await this.contract()).rewardsContract();
   }
-  get contractAddress() {
-    return assertEx5(this._contractAddress, () => "contractAddress is required");
+  async stakingTokenAddress() {
+    return await (await this.contract()).stakingTokenAddress();
   }
-  get provider() {
-    return assertEx5(this.params.provider, () => "provider is required");
+  async withdrawStake(slot) {
+    const result = await (await this.contract()).withdrawStake(slot);
+    await result.wait();
+    return true;
   }
-  async createHandler() {
-    await super.createHandler();
-    try {
-      this._contractAddress = await this.chainService.rewardsContract();
-    } catch (ex) {
-      const error = ex;
-      throw new Error(`Failed to get rewards contract address: ${error.message}`);
-    }
+  async withdrawn() {
+    return await (await this.contract()).withdrawn();
   }
-  async getRewardForBlock(blockNumber) {
-    const contract = XyoChainRewardsFactory.connect(toEthAddress(this.contractAddress), this.provider);
-    return await contract.calcBlockReward(blockNumber);
+  async withdrawnByStaker(staker) {
+    return await (await this.contract()).withdrawnByStaker(getAddress(staker));
   }
 };
-EvmBlockRewardService = _ts_decorate6([
-  creatable6()
-], EvmBlockRewardService);
 
-// src/BlockReward/MemoryBlockRewardService.ts
-import { assertEx as assertEx6, creatable as creatable7, toFixedPoint } from "@xylabs/sdk-js";
-import { rewardFromBlockNumber } from "@xyo-network/chain-protocol";
-function _ts_decorate7(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  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 MemoryBlockRewardService = class extends BaseBlockRewardService {
+// src/ChainService/Memory/Memory.ts
+import { assertEx as assertEx5, toAddress as toAddress2, ZERO_ADDRESS } from "@xylabs/sdk-js";
+var MemoryChainService = class extends BaseService {
   static {
-    __name(this, "MemoryBlockRewardService");
+    __name(this, "MemoryChainService");
   }
-  rewardFromBlockNumber = rewardFromBlockNumber(18);
-  get creatorReward() {
-    return assertEx6(this.params.creatorReward, () => "creatorReward is required");
+  _chainId;
+  _simulatedStake = 1n;
+  async active() {
+    return await Promise.resolve(this._simulatedStake);
   }
-  get initialReward() {
-    return assertEx6(this.params.initialStepReward, () => "initialStepReward is required");
+  async activeByStaked(_staked) {
+    return await Promise.resolve(this._simulatedStake);
   }
-  get minRewardPerBlock() {
-    return assertEx6(this.params.minRewardPerBlock, () => "minRewardPerBlock is required");
+  async activeByStaker(_address) {
+    return await Promise.resolve(this._simulatedStake);
   }
-  get stepFactorDenominator() {
-    return assertEx6(this.params.stepFactorDenominator, () => "stepFactorDenominator is required");
+  async addStake(_staked, _amount) {
+    return await Promise.resolve(true);
   }
-  get stepFactorNumerator() {
-    return assertEx6(this.params.stepFactorNumerator, () => "stepFactorNumerator is required");
-  }
-  get stepSize() {
-    return assertEx6(this.params.stepSize, () => "stepSize is required");
-  }
-  static async paramsHandler(inParams) {
-    return {
-      ...await super.paramsHandler(inParams),
-      creatorReward: inParams?.creatorReward ?? toFixedPoint(20000000000n),
-      initialStepReward: inParams?.initialStepReward ?? toFixedPoint(3000n),
-      minRewardPerBlock: inParams?.minRewardPerBlock ?? toFixedPoint(30n),
-      stepFactorDenominator: inParams?.stepFactorDenominator ?? 100n,
-      stepFactorNumerator: inParams?.stepFactorNumerator ?? 90n,
-      stepSize: inParams?.stepSize ?? 1000000n
-    };
-  }
-  getRewardForBlock(blockNumber) {
-    return this.rewardFromBlockNumber(blockNumber, this.initialReward, this.stepSize, this.stepFactorNumerator, this.stepFactorDenominator, this.minRewardPerBlock, this.creatorReward);
-  }
-};
-MemoryBlockRewardService = _ts_decorate7([
-  creatable7()
-], MemoryBlockRewardService);
-
-// src/blockViewerFromChainIteratorAndArchivist.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
-import { asSignedBlockBoundWitness, asSignedBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
-function blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist) {
-  const result = {
-    blockByHash: /* @__PURE__ */ __name(async function(hash) {
-      const [payload] = await chainArchivist.get([
-        hash
-      ]);
-      const block = asSignedBlockBoundWitnessWithStorageMeta(payload);
-      if (isDefined2(block)) {
-        const payloads = await chainArchivist.get(block.payload_hashes);
-        return [
-          block,
-          payloads
-        ];
-      }
-      return null;
-    }, "blockByHash"),
-    blockByNumber: /* @__PURE__ */ __name(async function(blockNumber) {
-      const payload = asSignedBlockBoundWitness(await chainIterator.get(blockNumber));
-      const block = payload ? await PayloadBuilder3.addHashMeta(payload) : void 0;
-      if (isDefined2(block)) {
-        const payloads = await chainArchivist.get(block.payload_hashes);
-        return [
-          block,
-          payloads
-        ];
-      }
-      return null;
-    }, "blockByNumber"),
-    blocksByHash: /* @__PURE__ */ __name(async function(hash, limit = 10) {
-      const results = [];
-      for (let i = 0; i < limit; i++) {
-        const block = await this.blockByHash(hash);
-        if (block) {
-          results.push(block);
-        } else {
-          break;
-        }
-      }
-      return results;
-    }, "blocksByHash"),
-    currentBlock: /* @__PURE__ */ __name(async function() {
-      const head = await chainIterator.head();
-      return this.blockByHash(head._hash);
-    }, "currentBlock"),
-    currentBlockHash: /* @__PURE__ */ __name(async function() {
-      const head = await chainIterator.head();
-      return head._hash;
-    }, "currentBlockHash"),
-    currentBlockNumber: /* @__PURE__ */ __name(async function() {
-      const head = await chainIterator.head();
-      return head.block;
-    }, "currentBlockNumber")
-  };
-  return result;
-}
-__name(blockViewerFromChainIteratorAndArchivist, "blockViewerFromChainIteratorAndArchivist");
-
-// src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
-import { assertEx as assertEx7, isDefined as isDefined3, isNull, isUndefined } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta, isBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
-import { LRUCache } from "lru-cache";
-var ChainBlockNumberIterationService = class extends BaseService {
-  static {
-    __name(this, "ChainBlockNumberIterationService");
-  }
-  _blocksByBlockNumber = new LRUCache({
-    max: 1e4
-  });
-  _currentHead;
-  get chainId() {
-    return assertEx7(this._currentHead?.chain ?? this.params?.head?.chain, () => "Current head is not set");
-  }
-  get chainMap() {
-    return assertEx7(this.params.chainMap);
-  }
-  async get(block) {
-    const head = await this.head();
-    assertEx7(head.block >= block, () => `Block requested is newer than the current head [${block}]`);
-    const cached = this._blocksByBlockNumber.get(block);
-    if (cached) return cached;
-    const startingBlock = head;
-    const currentBlockHash = await PayloadBuilder4.hash(startingBlock);
-    let currentBlock = await this.chainMap.get(currentBlockHash);
-    while (isDefined3(currentBlock)) {
-      assertEx7(asBlockBoundWitness2(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`);
-      if (isBlockBoundWitnessWithHashMeta(currentBlock)) {
-        this._blocksByBlockNumber.set(currentBlock.block, currentBlock);
-        if (currentBlock.block === block) {
-          return currentBlock;
-        }
-        const { previous } = currentBlock;
-        if (isNull(previous)) break;
-        currentBlock = await this.chainMap.get(previous);
-      }
-    }
-    throw new Error(`Block not found: ${block}`);
-  }
-  async head() {
-    if (isDefined3(this._currentHead)) return this._currentHead;
-    if (isDefined3(this.params.head)) {
-      const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(this.params.head);
-      this._currentHead = newHead;
-      return newHead;
-    }
-    throw new Error("Head is not set");
-  }
-  async next(block) {
-    const currentBlock = block;
-    const nextBlockNumber = currentBlock + 1;
-    return await this.get(nextBlockNumber);
-  }
-  // TODO: Decide on inclusive/exclusive (probably need inclusive to account for chain head)
-  // and then communicate via method name and documentation
-  async previous(block = void 0, count = 1) {
-    const results = [];
-    let currentBlock = isDefined3(block) ? await this.get(block) : await this.head();
-    while (isDefined3(currentBlock) && results.length < count) {
-      if (isBlockBoundWitnessWithHashMeta(currentBlock)) {
-        results.push(currentBlock);
-        const { previous } = currentBlock;
-        if (isNull(previous)) break;
-        const nextBlock = await this.chainMap.get(previous);
-        currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock);
-      } else {
-        const hash = PayloadBuilder4.hash(currentBlock);
-        assertEx7(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`);
-      }
-    }
-    return results;
-  }
-  async updateHead(head) {
-    const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head);
-    this._currentHead = newHead;
-    void this.emit("headUpdated", {
-      blocks: [
-        newHead
-      ]
-    });
-  }
-  async getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head) {
-    const hash = await PayloadBuilder4.hash(head);
-    const stored = await this.chainMap.get(hash);
-    const newHead = asBlockBoundWitnessWithStorageMeta(stored);
-    if (isUndefined(newHead)) throw new Error(`Head block not found in archivist [${hash}]`);
-    return newHead;
-  }
-};
-
-// src/ChainService/Evm/Evm.ts
-import { assertEx as assertEx8, toAddress, toEthAddress as toEthAddress2 } from "@xylabs/sdk-js";
-import { StakedXyoChain__factory as StakedXyoChainFactory } from "@xyo-network/typechain";
-import { getAddress } from "ethers/address";
-var EvmChainService = class extends BaseService {
-  static {
-    __name(this, "EvmChainService");
-  }
-  get chainId() {
-    return assertEx8(this.params.id);
-  }
-  get contract() {
-    if (this.params.contract === void 0) {
-      this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(this.chainId), this.params.runner);
-    }
-    return assertEx8(this.params.contract);
-  }
-  get runner() {
-    return assertEx8(this.params.runner);
-  }
-  async active() {
-    return await this.contract.active();
-  }
-  async activeByStaked(staked) {
-    return await this.contract.activeByAddressStaked(getAddress(toEthAddress2(staked)));
-  }
-  async activeByStaker(address) {
-    return await this.contract.activeByStaker(getAddress(toEthAddress2(address)));
-  }
-  async addStake(staked, amount) {
-    const result = await this.contract.addStake(getAddress(toEthAddress2(staked)), amount);
-    await result.wait();
-    return true;
-  }
-  async forkedAtBlockNumber() {
-    return await this.contract.forkedAtBlockNumber();
-  }
-  async forkedAtHash() {
-    return await this.contract.forkedAtHash();
-  }
-  async forkedChainId() {
-    return toAddress(await this.contract.forkedChainId());
-  }
-  async minWithdrawalBlocks() {
-    return await this.contract.minWithdrawalBlocks();
-  }
-  async pending() {
-    return await this.contract.pending();
-  }
-  async pendingByStaker(staker) {
-    return await this.contract.pendingByStaker(getAddress(toEthAddress2(staker)));
-  }
-  async removeStake(slot) {
-    const result = await this.contract.removeStake(slot);
-    await result.wait();
-    return true;
-  }
-  async rewardsContract() {
-    return await this.contract.rewardsContract();
-  }
-  async stakingTokenAddress() {
-    return await this.contract.stakingTokenAddress();
-  }
-  async withdrawStake(slot) {
-    const result = await this.contract.withdrawStake(slot);
-    await result.wait();
-    return true;
-  }
-  async withdrawn() {
-    return await this.contract.withdrawn();
-  }
-  async withdrawnByStaker(staker) {
-    return await this.contract.withdrawnByStaker(getAddress(staker));
-  }
-};
-
-// src/ChainService/Memory/Memory.ts
-import { assertEx as assertEx9, toAddress as toAddress2, ZERO_ADDRESS } from "@xylabs/sdk-js";
-var MemoryChainService = class extends BaseService {
-  static {
-    __name(this, "MemoryChainService");
-  }
-  _chainId;
-  _simulatedStake = 1n;
-  get chainId() {
-    return assertEx9(this._chainId, () => "Chain ID not set");
-  }
-  async active() {
-    return await Promise.resolve(this._simulatedStake);
-  }
-  async activeByStaked(_staked) {
-    return await Promise.resolve(this._simulatedStake);
-  }
-  async activeByStaker(_address) {
-    return await Promise.resolve(this._simulatedStake);
-  }
-  async addStake(_staked, _amount) {
-    return await Promise.resolve(true);
+  chainId() {
+    return assertEx5(this._chainId, () => "Chain ID not set");
   }
   createHandler() {
     const { minStake = 1 } = this.params.config.producer ?? {};
@@ -897,6 +489,9 @@ var MemoryChainService = class extends BaseService {
   async removeStake(_slot) {
     return await Promise.resolve(true);
   }
+  rewardForBlock(_block) {
+    throw new Error("Method not implemented.");
+  }
   async rewardsContract() {
     return await Promise.resolve("");
   }
@@ -919,77 +514,75 @@ var MemoryChainService = class extends BaseService {
 };
 
 // src/ChainValidator/XyoValidator.ts
-import { assertEx as assertEx10, creatable as creatable8 } from "@xylabs/sdk-js";
-function _ts_decorate8(decorators, target, key, desc) {
+import { assertEx as assertEx6, creatable as creatable3 } from "@xylabs/sdk-js";
+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_decorate8, "_ts_decorate");
+__name(_ts_decorate3, "_ts_decorate");
 var XyoValidator = class extends BaseService {
   static {
     __name(this, "XyoValidator");
   }
-  get address() {
-    return this.account.address;
-  }
-  get account() {
-    return assertEx10(this.params.account, () => "account is required");
-  }
-  get chainArchivist() {
-    return assertEx10(this.params.chainArchivist, () => "chainArchivist is required");
-  }
-  get chainInfo() {
-    return assertEx10(this.params.chainId, () => "chainInfo is required");
-  }
-  get electionService() {
-    return assertEx10(this.params.electionService, () => "electionService is required");
-  }
-  get pendingBundledTransactionsArchivist() {
-    return assertEx10(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
-  }
-  get rewardService() {
-    return assertEx10(this.params.rewardService, () => "rewardService is required");
-  }
+  // get address() {
+  //   return this.account.address
+  // }
+  // protected get account() {
+  //   return assertEx(this.params.account, () => 'account is required')
+  // }
+  get blockViewer() {
+    return assertEx6(this.params.blockViewer, () => "blockViewer is required");
+  }
+  // protected get chainInfo() {
+  //   return assertEx(this.params.chainId, () => 'chainInfo is required')
+  // }
+  // protected get electionService() {
+  //   return assertEx(this.params.electionService, () => 'electionService is required')
+  // }
+  // protected get pendingBundledTransactionsArchivist() {
+  //   return assertEx(this.params.pendingBundledTransactionsArchivist, () => 'pendingBundledTransactions is required')
+  // }
+  // protected get blockRewardService() {
+  //   return assertEx(this.params.blockRewardService, () => 'blockRewardService is required')
+  // }
   validatePendingBlock(_block) {
     return [];
   }
   // 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.blockViewer.blockByHash(tx._hash) !== void 0) return false;
     return await Promise.resolve(true);
   }
 };
-XyoValidator = _ts_decorate8([
-  creatable8()
+XyoValidator = _ts_decorate3([
+  creatable3()
 ], XyoValidator);
 
 // src/Election/BaseElectionService.ts
-import { assertEx as assertEx11, creatable as creatable9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7, creatable as creatable4 } from "@xylabs/sdk-js";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
-function _ts_decorate9(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_decorate9, "_ts_decorate");
+__name(_ts_decorate4, "_ts_decorate");
 var BaseElectionService = class extends BaseService {
   static {
     __name(this, "BaseElectionService");
   }
-  get chainIterator() {
-    return assertEx11(this.params.chainIterator, () => "No chain iterator");
+  get blockViewer() {
+    return assertEx7(this.params.blockViewer, () => "No block viewer");
   }
   get chainStakeViewer() {
-    return assertEx11(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx7(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx11(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx7(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
@@ -1006,96 +599,490 @@ var BaseElectionService = class extends BaseService {
     return creatorArray.slice(0, maxSize);
   }
 };
-BaseElectionService = _ts_decorate9([
-  creatable9()
+BaseElectionService = _ts_decorate4([
+  creatable4()
 ], BaseElectionService);
 
-// src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts
-import { creatable as creatable10 } from "@xylabs/sdk-js";
-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 BaseNetworkStakeStepRewardService = class extends BaseService {
-  static {
-    __name(this, "BaseNetworkStakeStepRewardService");
+// src/implementation/accountBalance.ts
+import { isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { AccountBalanceViewerRpcSchemas, HttpRpcTransport, JsonRpcAccountBalanceViewer } from "@xyo-network/xl1-rpc";
+var balanceServiceSingleton;
+var initAccountBalanceService = /* @__PURE__ */ __name((params) => {
+  const { config, logger } = params;
+  if (balanceServiceSingleton) return balanceServiceSingleton;
+  const endpoint = config.services?.accountBalanceViewerEndpoint ?? config.services?.apiEndpoint;
+  if (isDefined3(endpoint)) {
+    const transport = new HttpRpcTransport(endpoint, {
+      ...AccountBalanceViewerRpcSchemas
+    });
+    const viewer = new JsonRpcAccountBalanceViewer(transport);
+    logger?.log("Using AccountBalanceViewer RPC service at", endpoint);
+    return viewer;
+  } else {
+    throw new Error("No AccountBalanceViewer endpoint configured");
   }
-  networkStakeStepRewardAddressHistory(_address) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardAddressReward(_context, _address) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardAddressShare(_context, _address) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardClaimedByAddress(_address) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardForPosition(_position, _range) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardForStep(_context) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardForStepForPosition(_context, _position) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardPoolRewards(_context) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardPoolShares(_context) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardPositionWeight(_context, _position) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardRandomizer(_context) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardStakerCount(_context) {
-    throw new Error("Method not implemented.");
-  }
-  networkStakeStepRewardUnclaimedByAddress(_address) {
-    throw new Error("Method not implemented.");
+}, "initAccountBalanceService");
+
+// src/implementation/blockViewer.ts
+import { isDefined as isDefined4 } from "@xylabs/sdk-js";
+import { BlockViewerRpcSchemas, HttpRpcTransport as HttpRpcTransport2, JsonRpcBlockViewer } from "@xyo-network/xl1-rpc";
+var blockViewerSingleton;
+var initBlockViewer = /* @__PURE__ */ __name((params) => {
+  const { config, logger } = params;
+  if (blockViewerSingleton) return blockViewerSingleton;
+  const endpoint = config.services?.apiEndpoint;
+  if (isDefined4(endpoint)) {
+    const transport = new HttpRpcTransport2(endpoint, {
+      ...BlockViewerRpcSchemas
+    });
+    const viewer = new JsonRpcBlockViewer(transport);
+    logger?.log("Using BlockViewer RPC service at", endpoint);
+    return viewer;
+  } else {
+    throw new Error("No BlockViewer endpoint configured");
   }
-  networkStakeStepRewardWeightForAddress(_context, _address) {
-    throw new Error("Method not implemented.");
+}, "initBlockViewer");
+
+// src/implementation/chain/index.ts
+import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+
+// src/implementation/chain/evm.ts
+import { asAddress, assertEx as assertEx12, isDefined as isDefined8, ZERO_ADDRESS as ZERO_ADDRESS2 } from "@xylabs/sdk-js";
+import { Wallet } from "ethers/wallet";
+
+// src/implementation/evm/initEvmProvider.ts
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+
+// src/implementation/evm/initInfuraProvider.ts
+import { assertEx as assertEx9, isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { InfuraProvider } from "ethers/providers";
+
+// src/implementation/evm/initChainId.ts
+import { assertEx as assertEx8, hexFrom, isDefined as isDefined5, isHex } from "@xylabs/sdk-js";
+var canUseChainId = /* @__PURE__ */ __name((config) => {
+  return isDefined5(config.evm.chainId);
+}, "canUseChainId");
+var getChainId = /* @__PURE__ */ __name((config) => {
+  const chainId = assertEx8(config.evm.chainId, () => "Missing config.evm.chainId");
+  if (isHex(chainId, {
+    prefix: true
+  })) {
+    const hex = hexFrom(chainId);
+    const parsed = Number.parseInt(hex, 16);
+    return parsed;
+  } else {
+    const parsed = Number.parseInt(chainId, 10);
+    return parsed;
+  }
+}, "getChainId");
+
+// src/implementation/evm/initInfuraProvider.ts
+var instance;
+var initInfuraProvider = /* @__PURE__ */ __name((config) => {
+  if (instance) return instance;
+  const providerConfig = getInfuraProviderConfig(config);
+  instance = Promise.resolve(new InfuraProvider(...providerConfig));
+  return instance;
+}, "initInfuraProvider");
+var canUseInfuraProvider = /* @__PURE__ */ __name((config) => {
+  return canUseChainId(config) && isDefined6(config.evm?.infura?.projectId) && isDefined6(config.evm?.infura?.projectSecret);
+}, "canUseInfuraProvider");
+var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
+  const projectId = assertEx9(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx9(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  return [
+    getChainId(config),
+    projectId,
+    projectSecret
+  ];
+}, "getInfuraProviderConfig");
+
+// src/implementation/evm/initJsonRpcProvider.ts
+import { assertEx as assertEx10, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { JsonRpcProvider } from "ethers/providers";
+var initJsonRpcProvider = /* @__PURE__ */ __name((config) => {
+  const providerConfig = getJsonRpcProviderConfig(config);
+  return Promise.resolve(new JsonRpcProvider(...providerConfig));
+}, "initJsonRpcProvider");
+var canUseJsonRpcProvider = /* @__PURE__ */ __name((config) => {
+  return canUseChainId(config) && isDefined7(config.evm.jsonRpc?.url);
+}, "canUseJsonRpcProvider");
+var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config) => {
+  const jsonRpcUrl = assertEx10(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  return [
+    jsonRpcUrl,
+    getChainId(config)
+  ];
+}, "getJsonRpcProviderConfig");
+
+// src/implementation/evm/initEvmProvider.ts
+var provider;
+var initEvmProvider = /* @__PURE__ */ __name(async ({ config }) => {
+  if (provider) return provider;
+  if (canUseInfuraProvider(config)) {
+    provider = initInfuraProvider(config);
+  } else if (canUseJsonRpcProvider(config)) {
+    provider = initJsonRpcProvider(config);
+  }
+  return assertEx11(await provider, () => "No provider available");
+}, "initEvmProvider");
+var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
+  return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
+}, "canUseEvmProvider");
+
+// src/implementation/chain/evm.ts
+var chainStakeServiceSingleton;
+var canUseEvmContractChainService = /* @__PURE__ */ __name((config) => {
+  const { id } = config.chain;
+  return isDefined8(id) && id !== ZERO_ADDRESS2 && canUseEvmProvider({
+    config
+  });
+}, "canUseEvmContractChainService");
+var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, config, traceProvider, meterProvider, logger }) => {
+  if (chainStakeServiceSingleton) return chainStakeServiceSingleton;
+  const emvStakingContractAddress = assertEx12(config.chain.id, () => "config.chain.id is required");
+  const id = assertEx12(asAddress(emvStakingContractAddress), () => "config.chain.id is not a valid address");
+  const provider2 = assertEx12(await initEvmProvider({
+    config
+  }));
+  const privateKey = assertEx12(account.private?.hex, () => "Account does not have a private key");
+  const runner = new Wallet(privateKey, provider2);
+  chainStakeServiceSingleton = EvmChainService.create({
+    id,
+    runner,
+    traceProvider,
+    meterProvider,
+    logger
+  });
+  const result = await chainStakeServiceSingleton;
+  await result.start();
+  return result;
+}, "initEvmContractChainService");
+
+// src/implementation/chain/index.ts
+var chainStakeServiceSingleton2;
+var initChainService = /* @__PURE__ */ __name(({ account, config, logger }) => {
+  logger?.log("ChainService: Initializing...");
+  const result = init({
+    config,
+    name: "ChainService",
+    account
+  });
+  logger?.log("ChainService: Initialized");
+  return result;
+}, "initChainService");
+var initMemoryChainService = /* @__PURE__ */ __name(async ({ config }) => {
+  const result = await MemoryChainService.create({
+    config,
+    name: "MemoryChainService"
+  });
+  assertEx13(await result.start(), () => "Failed to start MemoryChainService");
+  return result;
+}, "initMemoryChainService");
+var init = /* @__PURE__ */ __name(async (params) => {
+  if (chainStakeServiceSingleton2) return chainStakeServiceSingleton2;
+  const { config } = params;
+  chainStakeServiceSingleton2 = canUseEvmContractChainService(config) ? await initEvmContractChainService({
+    ...params,
+    name: "ChainStakeService"
+  }) : await initMemoryChainService(params);
+  return chainStakeServiceSingleton2;
+}, "init");
+
+// src/implementation/head/head.ts
+import { assertEx as assertEx14, isDefined as isDefined10 } from "@xylabs/sdk-js";
+import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/xl1-protocol-sdk";
+
+// src/implementation/head/createBootstrapHead.ts
+import { buildNextBlock, createDeclarationIntent, createGenesisBlock } from "@xyo-network/chain-protocol";
+var createBootstrapHead = /* @__PURE__ */ __name(async (account, chainService) => {
+  const chainId = await chainService.chainId();
+  const chain = [];
+  const genesisBlock = await createGenesisBlock(account, chainId, 10000000n, account.address);
+  chain.push(genesisBlock);
+  const producerDeclarationPayload = createDeclarationIntent(account.address, "producer", genesisBlock[0].block, genesisBlock[0].block + 1e4);
+  const producerDeclarationBlock = await buildNextBlock(genesisBlock[0], [], [
+    producerDeclarationPayload
+  ], [
+    account
+  ]);
+  chain.push(producerDeclarationBlock);
+  return chain;
+}, "createBootstrapHead");
+
+// src/implementation/head/createForkedHead/getBridgeDestinationObservation.ts
+import { buildNextBlock as buildNextBlock2 } from "@xyo-network/chain-protocol";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { BridgeDestinationObservationSchema } from "@xyo-network/xl1-protocol";
+
+// src/implementation/head/createForkedHead/config/getBridgeDestinationDetails.ts
+import { toHex as toHex2 } from "@xylabs/sdk-js";
+
+// src/implementation/head/createForkedHead/config/getForkDetails.ts
+import { toHex } from "@xylabs/sdk-js";
+import { AttoXL1ConvertFactor } from "@xyo-network/xl1-protocol";
+var getForkBlockReward = /* @__PURE__ */ __name(() => {
+  return 18000000000n * AttoXL1ConvertFactor.xl1;
+}, "getForkBlockReward");
+var getForkBlockRewardHex = /* @__PURE__ */ __name(() => {
+  return toHex(getForkBlockReward());
+}, "getForkBlockRewardHex");
+
+// src/implementation/head/createForkedHead/config/getBridgeDestinationDetails.ts
+var ethChainId = toHex2("0x1");
+var bridgeableTokenContract = toHex2("0xf72aE3E0DA743033AbD7A407557D684c1aE66aed");
+var bridgeDestAddress = toHex2("0x0e65b65B10C791942665030402c35023d88B14dA");
+var destConfirmation = toHex2("0x950861b10523b52cdbb4a9ee52ed26601db555d2652bfec21c709e5e70d5b7d3");
+var getBridgeDestChainId = /* @__PURE__ */ __name(() => ethChainId, "getBridgeDestChainId");
+var getBridgeDestToken = /* @__PURE__ */ __name(() => bridgeableTokenContract, "getBridgeDestToken");
+var getBridgeDestAddress = /* @__PURE__ */ __name(() => bridgeDestAddress, "getBridgeDestAddress");
+var getBridgeDestAmount = /* @__PURE__ */ __name(() => getForkBlockRewardHex(), "getBridgeDestAmount");
+var getBridgeDestConfirmation = /* @__PURE__ */ __name(() => destConfirmation, "getBridgeDestConfirmation");
+var getBridgeDestinationDetails = /* @__PURE__ */ __name(() => {
+  return {
+    dest: getBridgeDestChainId(),
+    destToken: getBridgeDestToken(),
+    destAddress: getBridgeDestAddress(),
+    destAmount: getBridgeDestAmount()
+  };
+}, "getBridgeDestinationDetails");
+
+// src/implementation/head/createForkedHead/config/getBridgeSourceDetails.ts
+var getBridgeSrcChainId = /* @__PURE__ */ __name((chainService) => chainService.chainId(), "getBridgeSrcChainId");
+var getBridgeSrcAddress = /* @__PURE__ */ __name((account) => account.address, "getBridgeSrcAddress");
+var getBridgeSrcToken = /* @__PURE__ */ __name((chainService) => chainService.chainId(), "getBridgeSrcToken");
+var getBridgeSrcAmount = /* @__PURE__ */ __name(() => getForkBlockRewardHex(), "getBridgeSrcAmount");
+var getBridgeSourceDetails = /* @__PURE__ */ __name(async (account, chainService) => {
+  return {
+    src: await getBridgeSrcChainId(chainService),
+    srcAddress: getBridgeSrcAddress(account),
+    srcToken: await getBridgeSrcToken(chainService),
+    srcAmount: getBridgeSrcAmount()
+  };
+}, "getBridgeSourceDetails");
+
+// src/implementation/head/createForkedHead/getBridgeDestinationObservation.ts
+var getBridgeDestinationObservation = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
+  const bridgeDestinationObservationFields = {
+    ...await getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    destConfirmation: getBridgeDestConfirmation()
+  };
+  const bridgeDestinationObservation = new PayloadBuilder3({
+    schema: BridgeDestinationObservationSchema
+  }).fields(bridgeDestinationObservationFields).build();
+  return await buildNextBlock2(previousBlock[0], [], [
+    bridgeDestinationObservation
+  ], [
+    account
+  ]);
+}, "getBridgeDestinationObservation");
+
+// src/implementation/head/createForkedHead/getBridgeIntent.ts
+import { buildNextBlock as buildNextBlock3, createTransferPayload } from "@xyo-network/chain-protocol";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { BridgeIntentSchema, XYO_BRIDGE_ADDRESS } from "@xyo-network/xl1-protocol";
+var getBridgeIntent = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
+  const transferPayload = createTransferPayload(account.address, {
+    [XYO_BRIDGE_ADDRESS]: getForkBlockReward()
+  });
+  const nonce = `${Date.now()}`;
+  const bridgeIntentFields = {
+    ...await getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    nonce
+  };
+  const bridgeIntent = new PayloadBuilder4({
+    schema: BridgeIntentSchema
+  }).fields(bridgeIntentFields).build();
+  return await buildNextBlock3(previousBlock[0], [], [
+    bridgeIntent,
+    transferPayload
+  ], [
+    account
+  ]);
+}, "getBridgeIntent");
+
+// src/implementation/head/createForkedHead/getBridgeSourceObservation.ts
+import { buildNextBlock as buildNextBlock4 } from "@xyo-network/chain-protocol";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { BridgeSourceObservationSchema } from "@xyo-network/xl1-protocol";
+var getBridgeSourceObservation = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
+  const srcTxHash = previousBlock[0]._hash;
+  const bridgeSourceObservationFields = {
+    ...await getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    // Observation
+    srcConfirmation: srcTxHash
+  };
+  const bridgeSourceObservation = new PayloadBuilder5({
+    schema: BridgeSourceObservationSchema
+  }).fields(bridgeSourceObservationFields).build();
+  return await buildNextBlock4(previousBlock[0], [], [
+    bridgeSourceObservation
+  ], [
+    account
+  ]);
+}, "getBridgeSourceObservation");
+
+// src/implementation/head/createForkedHead/getFirstBlockForNewChain.ts
+import { buildBlock } from "@xyo-network/chain-protocol";
+import { AttoXL1, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
+var getFirstBlockForNewChain = /* @__PURE__ */ __name(async (forkBlock, account, chainService) => {
+  const { _hash: previousBlockHash, block: previousBlockNumber, step_hashes: previousStepHashes = [], protocol } = forkBlock;
+  const chainId = await chainService.chainId();
+  const options = {
+    blockPayloads: [],
+    chainId,
+    previousBlockHash,
+    previousBlockNumber,
+    previousStepHashes,
+    signers: [
+      account
+    ],
+    txs: [],
+    protocol,
+    chainStepRewardAddress: XYO_STEP_REWARD_ADDRESS,
+    stepRewardPoolBalance: AttoXL1(0n)
+  };
+  return await buildBlock(options);
+}, "getFirstBlockForNewChain");
+
+// src/implementation/head/createForkedHead/createForkedHead.ts
+var createForkedHead = /* @__PURE__ */ __name(async (forkFromBlock, account, chainService) => {
+  const chain = [];
+  const firstBlockForNewChain = await getFirstBlockForNewChain(forkFromBlock, account, chainService);
+  chain.push(firstBlockForNewChain);
+  const bridgeIntent = await getBridgeIntent(firstBlockForNewChain, account, chainService);
+  chain.push(bridgeIntent);
+  const bridgeSourceObservation = await getBridgeSourceObservation(bridgeIntent, account, chainService);
+  chain.push(bridgeSourceObservation);
+  const bridgeDestinationObservation = await getBridgeDestinationObservation(bridgeSourceObservation, account, chainService);
+  chain.push(bridgeDestinationObservation);
+  return chain;
+}, "createForkedHead");
+
+// src/implementation/head/getForkFromBlock.ts
+import { asHash, hexFromBigInt, isDefined as isDefined9 } from "@xylabs/sdk-js";
+import { isSignedBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
+var getForkFromBlock = /* @__PURE__ */ __name(async (head, chainService, chainArchivist) => {
+  if (head.chain !== await chainService.chainId()) {
+    const forkedAtBigInt = await chainService.forkedAtHash();
+    const forkedAtHex = hexFromBigInt(forkedAtBigInt);
+    const forkedAtHash = asHash(forkedAtHex);
+    if (isDefined9(forkedAtHash)) {
+      const [forkedAtBlock] = await chainArchivist.get([
+        forkedAtHash
+      ]);
+      const forkedChainId = await chainService.forkedChainId();
+      const forkedAtBlockNumber = Number(await chainService.forkedAtBlockNumber());
+      if (isSignedBlockBoundWitnessWithHashMeta(forkedAtBlock) && forkedAtBlock.chain === forkedChainId && forkedAtBlock.block === forkedAtBlockNumber) {
+        return forkedAtBlock;
+      }
+    }
   }
-  networkStakeStepRewardsForPosition(_position, _range) {
-    throw new Error("Method not implemented.");
+}, "getForkFromBlock");
+
+// src/implementation/head/submitNewChain.ts
+import { delay } from "@xylabs/sdk-js";
+import { flattenHydratedBlock } from "@xyo-network/xl1-protocol-sdk";
+var submitNewChain = /* @__PURE__ */ __name(async (chain, chainArchivist, chainSubmissionsArchivistWrite) => {
+  for (const block of chain) {
+    const [bw] = block;
+    await chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(block));
+    while (true) {
+      const result = await chainArchivist.get([
+        bw._hash
+      ]);
+      if (result.length > 0) break;
+      await delay(1e3);
+    }
   }
-  networkStakeStepRewardsForRange(_range) {
-    throw new Error("Method not implemented.");
+}, "submitNewChain");
+
+// src/implementation/head/head.ts
+var headSingleton;
+var initHead = /* @__PURE__ */ __name(async (params) => {
+  const { account, chainArchivist, chainSubmissionsArchivistWrite, chainService } = params;
+  if (headSingleton) return headSingleton;
+  let head = await findMostRecentBlock2(chainArchivist);
+  if (head) {
+    const forkFromBlock = await getForkFromBlock(head, chainService, chainArchivist);
+    if (isDefined10(forkFromBlock)) {
+      const chain = await createForkedHead(forkFromBlock, account, chainService);
+      await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite);
+      const newBlock = assertEx14(chain.at(-1), () => new Error("Failed to get new head after forking"));
+      head = newBlock[0];
+    }
+  } else {
+    const chain = await createBootstrapHead(account, chainService);
+    await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite);
+    const newBlock = assertEx14(chain.at(-1), () => new Error("Failed to get new head after genesis"));
+    head = newBlock[0];
+  }
+  headSingleton = head;
+  return headSingleton;
+}, "initHead");
+
+// src/implementation/mempoolRunner.ts
+import { isDefined as isDefined11 } from "@xylabs/sdk-js";
+import { HttpRpcTransport as HttpRpcTransport3, JsonRpcMempoolRunner, MempoolRunnerRpcSchemas } from "@xyo-network/xl1-rpc";
+var mempoolRunnerSingleton;
+var initMempoolRunner = /* @__PURE__ */ __name((params) => {
+  const { config, logger } = params;
+  if (mempoolRunnerSingleton) return mempoolRunnerSingleton;
+  const endpoint = config.services?.apiEndpoint;
+  if (isDefined11(endpoint)) {
+    const transport = new HttpRpcTransport3(endpoint, {
+      ...MempoolRunnerRpcSchemas
+    });
+    const runner = new JsonRpcMempoolRunner(transport);
+    logger?.log("Using mempoolRunner RPC service at", endpoint);
+    return runner;
+  } else {
+    throw new Error("No MempoolRunner endpoint configured");
   }
-  networkStakeStepRewardsForStepLevel(_stepLevel, _range) {
-    throw new Error("Method not implemented.");
+}, "initMempoolRunner");
+
+// src/implementation/mempoolViewer.ts
+import { isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { HttpRpcTransport as HttpRpcTransport4, JsonRpcMempoolViewer, MempoolViewerRpcSchemas } from "@xyo-network/xl1-rpc";
+var mempoolViewerSingleton;
+var initMempoolViewer = /* @__PURE__ */ __name((params) => {
+  const { config, logger } = params;
+  if (mempoolViewerSingleton) return mempoolViewerSingleton;
+  const endpoint = config.services?.apiEndpoint;
+  if (isDefined12(endpoint)) {
+    const transport = new HttpRpcTransport4(endpoint, {
+      ...MempoolViewerRpcSchemas
+    });
+    const viewer = new JsonRpcMempoolViewer(transport);
+    logger?.log("Using MempoolViewer RPC service at", endpoint);
+    return viewer;
+  } else {
+    throw new Error("No MempoolViewer endpoint configured");
   }
-};
-BaseNetworkStakeStepRewardService = _ts_decorate10([
-  creatable10()
-], BaseNetworkStakeStepRewardService);
+}, "initMempoolViewer");
+
+// src/implementation/pendingTransactions.ts
+import { isDefined as isDefined14 } from "@xylabs/sdk-js";
+import { timeBudget } from "@xyo-network/xl1-protocol-sdk";
+import { HttpRpcTransport as HttpRpcTransport5, JsonRpcMempoolViewer as JsonRpcMempoolViewer2, MempoolViewerRpcSchemas as MempoolViewerRpcSchemas2 } from "@xyo-network/xl1-rpc";
 
 // src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
-import { assertEx as assertEx12, creatable as creatable11, exists as exists2, filterAs, filterAsync, forget, isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx15, creatable as creatable5, exists, filterAs, filterAsync, forget, isDefined as isDefined13, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
-import { asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { asBlockBoundWitnessWithHashMeta, asXL1BlockNumber as asXL1BlockNumber2, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { findMostRecentBlock as findMostRecentBlock3 } from "@xyo-network/xl1-protocol-sdk";
 import { TransactionJsonSchemaValidator, validateTransaction } from "@xyo-network/xl1-validation";
 import { Mutex as Mutex2 } from "async-mutex";
 
 // src/PendingTransactions/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 import { asSignedTransactionBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withHashMeta = await PayloadBuilder5.addHashMeta(payload.payloads);
+  const withHashMeta = await PayloadBuilder6.addHashMeta(payload.payloads);
   const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
@@ -1106,7 +1093,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) => {
@@ -1114,8 +1101,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,
@@ -1124,13 +1111,13 @@ var bundle = /* @__PURE__ */ __name((root, transaction) => {
 }, "bundle");
 
 // src/PendingTransactions/BasePendingTransactions.ts
-function _ts_decorate11(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_decorate11, "_ts_decorate");
+__name(_ts_decorate5, "_ts_decorate");
 var BasePendingTransactionsService = class _BasePendingTransactionsService extends BaseService {
   static {
     __name(this, "BasePendingTransactionsService");
@@ -1177,213 +1164,729 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
   get additionalPendingTransactionValidators() {
     return this.params.additionalPendingTransactionValidators ?? [];
   }
-  get chainArchivist() {
-    return assertEx12(this.params.chainArchivist, () => "No completed blocks with data archivist");
+  get chainArchivist() {
+    return assertEx15(this.params.chainArchivist, () => "No completed blocks with data archivist");
+  }
+  get chainId() {
+    return assertEx15(this.params.chainId, () => "No chain id");
+  }
+  get pendingBundledTransactionsArchivist() {
+    return assertEx15(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+  }
+  get pendingBundledTransactionsLocalArchivist() {
+    return assertEx15(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+  }
+  get pendingTransactionsCount() {
+    forget(this.countPendingTransactions());
+    return this._pendingTransactionsCount;
+  }
+  get rejectedTransactionsArchivist() {
+    return assertEx15(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._curatedPendingBundledTransactionsArchivist = await MemoryArchivist.create({
+      account: "random"
+    });
+    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",
+      valueType: ValueType.INT,
+      unit: "1"
+    });
+    pendingTransactionsCounter?.addCallback((observer) => {
+      observer.observe(this.pendingTransactionsCount);
+    });
+  }
+  pendingBlocks(_options) {
+    throw new Error("Method [pendingBlocks] not implemented.");
+  }
+  async pendingTransactions({ limit = 100 } = {}) {
+    return await this.spanAsync("getPendingTransactions", async () => {
+      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
+        let lastHead = filterAs(await this.chainArchivist.next({
+          limit: 100
+        }), (x) => asBlockBoundWitnessWithHashMeta(x)).at(-1);
+        if (isUndefined2(lastHead)) return [];
+        await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
+        const foundPendingTransactions = [];
+        let cursor;
+        while (foundPendingTransactions.length < limit) {
+          const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
+            limit: 100,
+            order: "asc",
+            cursor
+          });
+          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(exists);
+          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber2(lastHead.block + 1, true)));
+          const txValidationResults = await Promise.all(activeTransactions.map(async (tx) => [
+            tx,
+            await validateTransaction(tx, {
+              chainId: this.chainId
+            }, this.additionalPendingTransactionValidators)
+          ]));
+          const validTransactions = txValidationResults.filter(([, errors]) => errors.length === 0).map(([tx]) => tx);
+          const invalidTransactions = txValidationResults.filter(([, errors]) => errors.length > 0).map(([tx]) => tx);
+          if (invalidTransactions.length > 0) {
+            this.logger?.warn(`getPendingTransactions: Found ${invalidTransactions.length} invalid pending transactions`);
+            for (const tx of invalidTransactions) {
+              this.logger?.warn(tx[0]._hash);
+            }
+          }
+          foundPendingTransactions.push(...validTransactions);
+        }
+        if (foundPendingTransactions.length > 0) {
+          this.logger?.log(`getPendingTransactions: Found ${foundPendingTransactions.length} pending transactions`);
+          for (const tx of foundPendingTransactions) {
+            this.logger?.log(tx[0]._hash);
+          }
+        }
+        return foundPendingTransactions;
+      }, _BasePendingTransactionsService.MutexPriority.ReadTransactions);
+    });
+  }
+  async cleanupWorker() {
+    return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
+      const lastHead = await findMostRecentBlock3(this.chainArchivist);
+      if (isDefined13(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
+    }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
+  }
+  async countPendingTransactions() {
+    if (this._countPendingTransactionsMutex.isLocked()) return;
+    await this._countPendingTransactionsMutex.runExclusive(async () => {
+      const payloads = await this._curatedPendingBundledTransactionsArchivist?.all() ?? [];
+      this._pendingTransactionsCount = payloads.length;
+    });
+  }
+  async filterAlreadyFinalizedTransactions(incomingTransactions) {
+    const incomingTransactionHashes = incomingTransactions.map((payload) => payload.root);
+    const finalizedTransactions = await this.chainArchivist.get(incomingTransactionHashes);
+    const finalizedTransactionHashes = new Set(finalizedTransactions.map((item) => item._hash));
+    const nonFinalizedTransactions = incomingTransactions.filter((item) => !finalizedTransactionHashes.has(item._hash));
+    return nonFinalizedTransactions;
+  }
+  async insertNewTransactions(payloads) {
+    if (payloads.length === 0) return;
+    return await this.spanAsync("InsertNewTransactions", async () => {
+      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
+        const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
+        const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map(async (tx) => {
+          return await bundledPayloadToHydratedTransaction(tx);
+        }))).filter(exists);
+        const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
+          const errors = await validateTransaction(tx, {
+            chainId: this.chainId
+          }, [
+            TransactionJsonSchemaValidator
+          ]);
+          if (errors.length > 0) {
+            this.logger?.warn("validateTransaction", errors);
+          }
+          return errors.length > 0 ? false : true;
+        });
+        if (validTransactions.length > 0) {
+          const bundledTransactions = validTransactions.map((tx) => hydratedTransactionToPayloadBundle(tx));
+          await this.pendingBundledTransactionsLocalArchivist.insert(bundledTransactions);
+        }
+      }, _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.
+  */
+  markAnyIncludedTransactionsForRemoval(payloads) {
+    const hashes = payloads.filter(isTransactionBoundWitnessWithStorageMeta).map((p) => p._hash);
+    for (const hash of hashes) {
+      this._removablePendingTransactionHashes.add(hash);
+    }
+  }
+  async pruneCuratedPendingTransactionsArchivist(head) {
+    return await this.spanAsync("pruneCuratedPendingTransactionsArchivist", async () => {
+      const foundPendingTransactionsToDeleteHashes = [];
+      let cursor;
+      let [lastHead] = filterAs(await this.chainArchivist.get([
+        head
+      ]), (x) => asBlockBoundWitnessWithHashMeta(x));
+      while (isDefined13(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(exists));
+        const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
+        const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists);
+        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber2(lastHead.block + 1, true)));
+        const expiredBundleHashes = expiredTransactions.map((expiredHydratedTx) => (
+          // Find the corresponding payload bundle hash for the expired transaction
+          pendingBundledTransactions.find((bundledTx) => bundledTx.root === expiredHydratedTx[0]._hash)?._hash
+        )).filter(exists);
+        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);
+        }
+      }
+    });
+  }
+};
+BasePendingTransactionsService = _ts_decorate5([
+  creatable5()
+], BasePendingTransactionsService);
+var isTransactionExpired = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.exp < block, "isTransactionExpired");
+var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block, "isTransactionActive");
+
+// src/implementation/pendingTransactions.ts
+var serviceSingleton;
+var initPendingTransactions = /* @__PURE__ */ __name(async ({ config, params, logger }) => {
+  if (serviceSingleton) return serviceSingleton;
+  return await timeBudget("initPendingTransactions", logger, async () => {
+    const endpoint = config.services?.apiEndpoint;
+    if (isDefined14(endpoint)) {
+      const transport = new HttpRpcTransport5(endpoint, {
+        ...MempoolViewerRpcSchemas2
+      });
+      const viewer = new JsonRpcMempoolViewer2(transport);
+      logger?.log("Using MempoolViewer RPC service at", endpoint);
+      return viewer;
+    } else {
+      serviceSingleton = await BasePendingTransactionsService.create(params);
+    }
+    return serviceSingleton;
+  }, 2e3, true);
+}, "initPendingTransactions");
+
+// src/implementation/producer.ts
+import { timeBudget as timeBudget2 } from "@xyo-network/xl1-protocol-sdk";
+
+// src/simple/block/runner/SimpleBlockRunner.ts
+import { AbstractCreatable as AbstractCreatable3, AddressZod, asHash as asHash2, assertEx as assertEx17, creatable as creatable6, exists as exists2, hexToBigInt, isDefined as isDefined15 } from "@xylabs/sdk-js";
+import { MemoryArchivist as MemoryArchivist2 } from "@xyo-network/archivist-memory";
+import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
+import { buildNextBlock as buildNextBlock5, createDeclarationIntent as createDeclarationIntent2 } from "@xyo-network/chain-protocol";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness as asBlockBoundWitness2, AttoXL1 as AttoXL12, BlockNumberSchema, defaultRewardRatio, TimeSchema, XYO_STEP_REWARD_ADDRESS as XYO_STEP_REWARD_ADDRESS2 } from "@xyo-network/xl1-protocol";
+import z from "zod";
+
+// src/simple/block/runner/generateTransactionFeeTransfers.ts
+import { hexFromBigInt as hexFromBigInt2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx16 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { TransferSchema, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-protocol";
+import { transactionRequiredGas } from "@xyo-network/xl1-protocol-sdk";
+import { HydratedTransactionWrapper } from "@xyo-network/xl1-wrappers";
+async function generateTransactionFeeTransfers(address, transactions) {
+  const txs = await Promise.all(transactions.map(async (tx) => {
+    return HydratedTransactionWrapper.parse([
+      await PayloadBuilder8.addStorageMeta(tx[0]),
+      await PayloadBuilder8.addStorageMeta(tx[1])
+    ]);
+  }));
+  const txBaseFeeCosts = {};
+  for (const tx of txs) {
+    txBaseFeeCosts[tx.boundWitness.from] = (txBaseFeeCosts[tx.boundWitness.from] ?? 0n) + tx.fees.base;
+  }
+  const txGasCosts = {};
+  for (const tx of txs) {
+    const requiredGas = transactionRequiredGas(tx.data);
+    const totalGasCost = requiredGas * tx.fees.gasPrice;
+    txGasCosts[tx.boundWitness.from] = (txBaseFeeCosts[tx.boundWitness.from] ?? 0n) + totalGasCost;
+  }
+  const payloads = Object.entries(txBaseFeeCosts).map(([from, amount]) => {
+    const payload = {
+      schema: TransferSchema,
+      epoch: Date.now(),
+      from,
+      transfers: {
+        // burn the base fee
+        [XYO_ZERO_ADDRESS]: hexFromBigInt2(amount)
+      }
+    };
+    return payload;
+  });
+  for (const [from, amount] of Object.entries(txGasCosts)) {
+    const fromPayload = assertEx16(payloads.find((p) => p.from === from), () => "from payload not found");
+    fromPayload.transfers[address] = hexFromBigInt2(amount);
+  }
+  return payloads;
+}
+__name(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
+
+// src/simple/block/runner/SimpleBlockRunner.ts
+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 DEFAULT_BLOCK_SIZE = 10;
+var XYO_PRODUCER_REDECLARATION_DURATION = 1e4;
+var XYO_PRODUCER_REDECLARATION_WINDOW = 500;
+var SimpleBlockRunnerParamsZod = z.object({
+  balanceViewer: z.object().loose(),
+  blockRewardViewer: z.object().loose(),
+  chainId: z.string(),
+  config: z.object().loose(),
+  mempoolViewer: z.object().loose(),
+  mempoolRunner: z.object().loose(),
+  rejectedTransactionsArchivist: z.object().loose().optional(),
+  rewardAddress: AddressZod,
+  time: z.object().loose(),
+  validateHydratedBlockState: z.function().optional()
+});
+var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
+  static {
+    __name(this, "SimpleBlockRunner");
+  }
+  _blockRewardDiviner;
+  _lastRedeclarationBlock;
+  _rejectedTransactionsArchivist;
+  /**
+  * 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;
+  }
+  get address() {
+    return this.account.address;
+  }
+  get account() {
+    return assertEx17(this.params.account, () => "account is required");
+  }
+  get balanceViewer() {
+    return assertEx17(this.params.balanceViewer, () => "balanceViewer is required");
+  }
+  get blockRewardViewer() {
+    return assertEx17(this.params.blockRewardViewer, () => "blockRewardViewer is required");
+  }
+  get chainId() {
+    return assertEx17(this.params.chainId, () => "chainId is required");
+  }
+  // protected get electionService() {
+  //   return assertEx(this.params.electionService, () => 'electionService is required')
+  // }
+  get mempoolRunner() {
+    return assertEx17(this.params.mempoolRunner, () => "mempoolRunner is required");
+  }
+  get mempoolViewer() {
+    return assertEx17(this.params.mempoolViewer, () => "mempoolViewer is required");
+  }
+  // protected get pendingTransactionsService() {
+  //   return assertEx(this.params.pendingTransactionsService, () => 'Missing pendingTransactionsService')
+  // }
+  get rejectedTransactionsArchivist() {
+    return this._rejectedTransactionsArchivist;
+  }
+  get rewardAddress() {
+    return assertEx17(this.params.rewardAddress, () => "No reward address provided");
+  }
+  // protected get stakeIntentService(): StakeIntentService {
+  //   return assertEx(this.params.stakeIntentService, () => 'No StakeIntentService provided')
+  // }
+  get time() {
+    return assertEx17(this.params.time, () => "No TimeSyncViewer provided");
+  }
+  // protected get validateHydratedBlockState() {
+  //   return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
+  // }
+  static async paramsHandler(params) {
+    SimpleBlockRunnerParamsZod.parse(params);
+    const rejectedTransactionsArchivist = params?.rejectedTransactionsArchivist ?? await MemoryArchivist2.create();
+    return {
+      ...await super.paramsHandler(params),
+      ...params,
+      rejectedTransactionsArchivist
+    };
+  }
+  async next(head) {
+    if (head.chain !== this.chainId) return;
+    return await this.proposeNextValidBlock(head);
+  }
+  async produceNextBlock(head, force) {
+    assertEx17(head.chain === this.chainId, () => "Block chain ID does not match");
+    const result = await this.proposeNextValidBlock(head);
+    return force ? assertEx17(result, () => "Failed to produce next block") : result;
+  }
+  async getBlockRewardTransfers(block) {
+    if (!this._blockRewardDiviner) {
+      this._blockRewardDiviner = await FixedPercentageBlockRewardDiviner.create({
+        account: "random",
+        blockRewardViewer: this.blockRewardViewer,
+        config: {
+          rewardAddress: this.rewardAddress,
+          rewardPercentageRatio: defaultRewardRatio,
+          schema: FixedPercentageBlockRewardDivinerConfigSchema
+        }
+      });
+    }
+    const blockId = new PayloadBuilder9({
+      schema: BlockNumberSchema
+    }).fields({
+      block
+    }).build();
+    const rewards = await this._blockRewardDiviner.divine([
+      blockId
+    ]);
+    return rewards;
+  }
+  /**
+  * 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
+  */
+  getProducerRedeclaration(head) {
+    if (this.params.config.producer.disableIntentRedeclaration) return;
+    const currentBlock = head.block;
+    return createDeclarationIntent2(this.address, "producer", currentBlock, currentBlock + _SimpleBlockRunner.RedeclarationDuration);
+  }
+  async proposeNextValidBlock(head, validateBalances = false, force = false) {
+    return await this.spanAsync("proposeNextValidBlock", async () => {
+      const { block: previousBlock } = assertEx17(asBlockBoundWitness2(head), () => "Invalid head block");
+      const nextBlock = previousBlock + 1;
+      const nextBlockTransactionsStart = Date.now();
+      const nextBlockTransactions = await this.mempoolViewer.pendingTransactions({
+        limit: _SimpleBlockRunner.DefaultBlockSize
+      });
+      const nextBlockTransactionsDuration = Date.now() - nextBlockTransactionsStart;
+      if (nextBlockTransactionsDuration > 200) {
+        this.logger?.warn(`[Slow] Fetched ${nextBlockTransactions.length} pending transactions in ${nextBlockTransactionsDuration}ms}`);
+      }
+      const blockPayloads = [];
+      const producerRedeclarationPayload = await this.getProducerRedeclaration(head);
+      if (producerRedeclarationPayload) blockPayloads.push(producerRedeclarationPayload);
+      if (blockPayloads.length === 0 && nextBlockTransactions.length === 0 && !this.heartbeatRequired(head) && !force) return;
+      const rewardTransferPayloads = await this.getBlockRewardTransfers(nextBlock);
+      blockPayloads.push(...rewardTransferPayloads);
+      const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions);
+      const timeStart = Date.now();
+      const timePayload = await this.generateTimePayload(head);
+      const timeDuration = Date.now() - timeStart;
+      if (timeDuration > 100) {
+        this.logger?.warn(`[Slow] Generated time payload in ${timeDuration}ms`);
+      }
+      const [fundedNextBlockTransactions, fundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, validateBalances);
+      blockPayloads.push(...fundedTransfers, timePayload);
+      this.logger?.info(`Building block ${head.block + 1}`);
+      const startBuild = Date.now();
+      const stepRewardPoolBalance = (await this.balanceViewer.accountBalances([
+        XYO_STEP_REWARD_ADDRESS2
+      ]))[XYO_STEP_REWARD_ADDRESS2];
+      const block = await buildNextBlock5(head, fundedNextBlockTransactions, blockPayloads, [
+        this.account
+      ], XYO_STEP_REWARD_ADDRESS2, stepRewardPoolBalance);
+      this.logger?.info(`Built block ${block[0].block} in ${Date.now() - startBuild}ms with ${block[1].length} payloads`);
+      await this.mempoolRunner.submitBlocks([
+        block
+      ]);
+      return block;
+    });
+  }
+  // remove unfunded transactions and block transfers
+  async filterByFunded(head, txs, transfers, validateBalances = false) {
+    const fundedTransfers = [];
+    const fundedTransactions = (await Promise.all(txs.map(async (tx) => {
+      const transfer = transfers.find((transfer2) => transfer2.from === tx[0].from);
+      if (!transfer) return;
+      const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? "00"), 0n);
+      if (validateBalances) {
+        const balance = (await this.balanceViewer.accountBalances([
+          transfer.from
+        ]))[transfer.from] ?? AttoXL12(0n);
+        if (balance >= totalTransferCost) {
+          fundedTransfers.push(transfer);
+          return tx;
+        }
+      } else {
+        fundedTransfers.push(transfer);
+        return tx;
+      }
+    }))).filter(exists2);
+    return [
+      fundedTransactions,
+      fundedTransfers
+    ];
+  }
+  async generateTimePayload(head) {
+    const [ethereum, ethHashOrNull] = await this.time.currentTimeAndHash("ethereum");
+    const ethereumHash = asHash2(ethHashOrNull, () => "No ethereum hash available from time sync service");
+    const timePayload = {
+      schema: TimeSchema,
+      // this is for the previous block
+      xl1: head.block,
+      // this is for the previous block
+      xl1Hash: head._hash,
+      ethereum,
+      ethereumHash,
+      epoch: Date.now()
+    };
+    return timePayload;
+  }
+  /**
+  * Check if a heartbeat block is required based on network activity.
+  * @param head The current head block
+  * @returns True if a heartbeat is required, false otherwise
+  */
+  heartbeatRequired(head) {
+    const epoch = head.$epoch;
+    if (isDefined15(epoch)) {
+      const { heartbeatInterval } = this.params.config.producer;
+      if (Date.now() - epoch > heartbeatInterval) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+SimpleBlockRunner = _ts_decorate6([
+  creatable6()
+], SimpleBlockRunner);
+
+// src/implementation/producer.ts
+var serviceSingleton2;
+var initBlockProducer = /* @__PURE__ */ __name(async (params) => {
+  if (serviceSingleton2) return serviceSingleton2;
+  return await timeBudget2("initBlockProducer", params.logger, async () => {
+    serviceSingleton2 = await SimpleBlockRunner.create(params);
+    return serviceSingleton2;
+  }, 2e3, true);
+}, "initBlockProducer");
+
+// src/implementation/reward.ts
+import { assertEx as assertEx18 } from "@xylabs/sdk-js";
+import { SimpleBlockRewardViewer, timeBudget as timeBudget3 } from "@xyo-network/xl1-protocol-sdk";
+var rewardServiceSingleton;
+var initBlockRewardViewer = /* @__PURE__ */ __name((params) => {
+  if (rewardServiceSingleton) return rewardServiceSingleton;
+  return timeBudget3("initBlockRewardViewer", params.logger, () => {
+    const { config } = params;
+    rewardServiceSingleton = canUseEvmBlockRewardViewer({
+      config
+    }) ? initEvmBlockRewardViewer(params) : initXyoBlockRewardViewer(params);
+    return rewardServiceSingleton;
+  }, 2e3, true);
+}, "initBlockRewardViewer");
+var initXyoBlockRewardViewer = /* @__PURE__ */ __name((params) => {
+  if (rewardServiceSingleton) return rewardServiceSingleton;
+  return timeBudget3("initXyoBlockRewardViewer", params.logger, () => {
+    rewardServiceSingleton = SimpleBlockRewardViewer.create(params);
+    return rewardServiceSingleton;
+  }, 2e3, true);
+}, "initXyoBlockRewardViewer");
+var canUseEvmBlockRewardViewer = /* @__PURE__ */ __name((params) => canUseEvmProvider({
+  config: params.config
+}), "canUseEvmBlockRewardViewer");
+var initEvmBlockRewardViewer = /* @__PURE__ */ __name(async (params) => {
+  if (rewardServiceSingleton) return rewardServiceSingleton;
+  return await timeBudget3("initEvmBlockRewardViewer", params.logger, async () => {
+    const provider2 = assertEx18(await initEvmProvider(params));
+    const evmBlockRewardViewerParams = {
+      ...params,
+      provider: provider2
+    };
+    rewardServiceSingleton = EvmBlockRewardViewer.create(evmBlockRewardViewerParams);
+    return rewardServiceSingleton;
+  }, 2e3, true);
+}, "initEvmBlockRewardViewer");
+
+// src/implementation/time.ts
+import { timeBudget as timeBudget4 } from "@xyo-network/xl1-protocol-sdk";
+
+// src/Time/BaseTimeSyncService.ts
+import { creatable as creatable7 } from "@xylabs/sdk-js";
+import { SimpleTimeSyncViewer } from "@xyo-network/xl1-protocol-sdk";
+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 BaseTimeSyncService = class extends BaseService {
+  static {
+    __name(this, "BaseTimeSyncService");
+  }
+  timeSyncViewer;
+  get blockViewer() {
+    return this.params.blockViewer;
+  }
+  get ethProvider() {
+    return this.params.ethProvider;
+  }
+  async convertTime(fromDomain, toDomain, from) {
+    return await this.timeSyncViewer.convertTime(fromDomain, toDomain, from);
+  }
+  async createHandler() {
+    await super.createHandler();
+    this.timeSyncViewer = new SimpleTimeSyncViewer(this.blockViewer, this.ethProvider);
+  }
+  async currentTime(domain) {
+    return await this.timeSyncViewer.currentTime(domain);
+  }
+  async currentTimeAndHash(domain) {
+    return await this.timeSyncViewer.currentTimeAndHash(domain);
+  }
+  async currentTimePayload() {
+    return await this.timeSyncViewer.currentTimePayload();
+  }
+};
+BaseTimeSyncService = _ts_decorate7([
+  creatable7()
+], BaseTimeSyncService);
+
+// src/implementation/time.ts
+var timeSyncServiceSingleton;
+var initTimeService = /* @__PURE__ */ __name(async ({ blockViewer, config, logger, meterProvider, traceProvider }) => {
+  if (timeSyncServiceSingleton) return timeSyncServiceSingleton;
+  return await timeBudget4("initTimeService", logger, async () => {
+    const ethProvider = canUseEvmProvider({
+      config
+    }) ? await initEvmProvider({
+      config
+    }) : void 0;
+    timeSyncServiceSingleton = BaseTimeSyncService.create({
+      blockViewer,
+      ethProvider,
+      logger,
+      meterProvider,
+      traceProvider
+    });
+    return await timeSyncServiceSingleton;
+  }, 2e3, true);
+}, "initTimeService");
+
+// src/implementation/validator.ts
+var serviceSingleton3;
+var initValidator = /* @__PURE__ */ __name((params) => {
+  if (serviceSingleton3) return serviceSingleton3;
+  serviceSingleton3 = initBlockProducer(params);
+  return serviceSingleton3;
+}, "initValidator");
+
+// src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts
+import { creatable as creatable8 } from "@xylabs/sdk-js";
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  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");
+var BaseNetworkStakeStepRewardService = class extends BaseService {
+  static {
+    __name(this, "BaseNetworkStakeStepRewardService");
+  }
+  networkStakeStepRewardAddressHistory(_address) {
+    throw new Error("Method [networkStakeStepRewardAddressHistory] not implemented.");
   }
-  get chainId() {
-    return assertEx12(this.params.chainId, () => "No chain id");
+  networkStakeStepRewardAddressReward(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardAddressReward] not implemented.");
   }
-  get pendingBundledTransactionsArchivist() {
-    return assertEx12(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+  networkStakeStepRewardAddressShare(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardAddressShare] not implemented.");
   }
-  get pendingBundledTransactionsLocalArchivist() {
-    return assertEx12(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+  networkStakeStepRewardClaimedByAddress(_address) {
+    throw new Error("Method [networkStakeStepRewardClaimedByAddress] not implemented.");
   }
-  get pendingTransactionsCount() {
-    forget(this.countPendingTransactions());
-    return this._pendingTransactionsCount;
+  networkStakeStepRewardForPosition(_position, _range) {
+    throw new Error("Method [networkStakeStepRewardForPosition] not implemented.");
   }
-  get rejectedTransactionsArchivist() {
-    return assertEx12(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
+  networkStakeStepRewardForStep(_context) {
+    throw new Error("Method [networkStakeStepRewardForStep] not implemented.");
   }
-  async createHandler() {
-    await super.createHandler();
-    this._curatedPendingBundledTransactionsArchivist = await MemoryArchivist.create({
-      account: "random"
-    });
-    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",
-      valueType: ValueType.INT,
-      unit: "1"
-    });
-    pendingTransactionsCounter?.addCallback((observer) => {
-      observer.observe(this.pendingTransactionsCount);
-    });
+  networkStakeStepRewardForStepForPosition(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardForStepForPosition] not implemented.");
   }
-  async getPendingTransactions(head, limit) {
-    return await this.spanAsync("getPendingTransactions", async () => {
-      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        let [lastHead] = filterAs(await this.chainArchivist.get([
-          head
-        ]), (x) => asBlockBoundWitnessWithHashMeta(x));
-        if (isUndefined2(lastHead)) return [];
-        await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
-        const foundPendingTransactions = [];
-        let cursor;
-        while (foundPendingTransactions.length < limit) {
-          const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
-            limit: 100,
-            order: "asc",
-            cursor
-          });
-          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(exists2);
-          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber(lastHead.block + 1, true)));
-          const txValidationResults = await Promise.all(activeTransactions.map(async (tx) => [
-            tx,
-            await validateTransaction(tx, {
-              chainId: this.chainId
-            }, this.additionalPendingTransactionValidators)
-          ]));
-          const validTransactions = txValidationResults.filter(([, errors]) => errors.length === 0).map(([tx]) => tx);
-          const invalidTransactions = txValidationResults.filter(([, errors]) => errors.length > 0).map(([tx]) => tx);
-          if (invalidTransactions.length > 0) {
-            this.logger?.warn(`getPendingTransactions: Found ${invalidTransactions.length} invalid pending transactions`);
-            for (const tx of invalidTransactions) {
-              this.logger?.warn(tx[0]._hash);
-            }
-          }
-          foundPendingTransactions.push(...validTransactions);
-        }
-        if (foundPendingTransactions.length > 0) {
-          this.logger?.log(`getPendingTransactions: Found ${foundPendingTransactions.length} pending transactions`);
-          for (const tx of foundPendingTransactions) {
-            this.logger?.log(tx[0]._hash);
-          }
-        }
-        return foundPendingTransactions;
-      }, _BasePendingTransactionsService.MutexPriority.ReadTransactions);
-    });
+  networkStakeStepRewardPoolRewards(_context) {
+    throw new Error("Method [networkStakeStepRewardPoolRewards] not implemented.");
   }
-  async cleanupWorker() {
-    return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-      const lastHead = await findMostRecentBlock2(this.chainArchivist);
-      if (isDefined4(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
-    }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
+  networkStakeStepRewardPoolShares(_context) {
+    throw new Error("Method [networkStakeStepRewardPoolShares] not implemented.");
   }
-  async countPendingTransactions() {
-    if (this._countPendingTransactionsMutex.isLocked()) return;
-    await this._countPendingTransactionsMutex.runExclusive(async () => {
-      const payloads = await this._curatedPendingBundledTransactionsArchivist?.all() ?? [];
-      this._pendingTransactionsCount = payloads.length;
-    });
+  networkStakeStepRewardPositionWeight(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardPositionWeight] not implemented.");
   }
-  async filterAlreadyFinalizedTransactions(incomingTransactions) {
-    const incomingTransactionHashes = incomingTransactions.map((payload) => payload.root);
-    const finalizedTransactions = await this.chainArchivist.get(incomingTransactionHashes);
-    const finalizedTransactionHashes = new Set(finalizedTransactions.map((item) => item._hash));
-    const nonFinalizedTransactions = incomingTransactions.filter((item) => !finalizedTransactionHashes.has(item._hash));
-    return nonFinalizedTransactions;
+  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardPotentialPositionLoss] not implemented.");
   }
-  async insertNewTransactions(payloads) {
-    if (payloads.length === 0) return;
-    return await this.spanAsync("InsertNewTransactions", async () => {
-      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
-        const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map(async (tx) => {
-          return await bundledPayloadToHydratedTransaction(tx);
-        }))).filter(exists2);
-        const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
-          const errors = await validateTransaction(tx, {
-            chainId: this.chainId
-          }, [
-            TransactionJsonSchemaValidator
-          ]);
-          if (errors.length > 0) {
-            this.logger?.warn("validateTransaction", errors);
-          }
-          return errors.length > 0 ? false : true;
-        });
-        if (validTransactions.length > 0) {
-          const bundledTransactions = validTransactions.map((tx) => hydratedTransactionToPayloadBundle(tx));
-          await this.pendingBundledTransactionsLocalArchivist.insert(bundledTransactions);
-        }
-      }, _BasePendingTransactionsService.MutexPriority.InsertNewTransactions);
-    });
+  networkStakeStepRewardRandomizer(_context) {
+    throw new Error("Method [networkStakeStepRewardRandomizer] not implemented.");
   }
-  /**
-  * 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) {
-      this._removablePendingTransactionHashes.add(hash);
-    }
+  networkStakeStepRewardStakerCount(_context) {
+    throw new Error("Method [networkStakeStepRewardStakerCount] not implemented.");
   }
-  async pruneCuratedPendingTransactionsArchivist(head) {
-    return await this.spanAsync("pruneCuratedPendingTransactionsArchivist", async () => {
-      const foundPendingTransactionsToDeleteHashes = [];
-      let cursor;
-      let [lastHead] = filterAs(await this.chainArchivist.get([
-        head
-      ]), (x) => asBlockBoundWitnessWithHashMeta(x));
-      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(exists2));
-        const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-        const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
-        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber(lastHead.block + 1, true)));
-        const expiredBundleHashes = expiredTransactions.map((expiredHydratedTx) => (
-          // Find the corresponding payload bundle hash for the expired transaction
-          pendingBundledTransactions.find((bundledTx) => bundledTx.root === expiredHydratedTx[0]._hash)?._hash
-        )).filter(exists2);
-        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);
-        }
-      }
-    });
+  networkStakeStepRewardUnclaimedByAddress(_address) {
+    throw new Error("Method [networkStakeStepRewardUnclaimedByAddress] not implemented.");
+  }
+  networkStakeStepRewardWeightForAddress(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardWeightForAddress] not implemented.");
+  }
+  networkStakeStepRewardsForPosition(_position, _range) {
+    throw new Error("Method [networkStakeStepRewardsForPosition] not implemented.");
+  }
+  networkStakeStepRewardsForRange(_range) {
+    throw new Error("Method [networkStakeStepRewardsForRange] not implemented.");
+  }
+  networkStakeStepRewardsForStepLevel(_stepLevel, _range) {
+    throw new Error("Method [networkStakeStepRewardsForStepLevel] not implemented.");
   }
 };
-BasePendingTransactionsService = _ts_decorate11([
-  creatable11()
-], BasePendingTransactionsService);
-var isTransactionExpired = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.exp < block, "isTransactionExpired");
-var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block, "isTransactionActive");
+BaseNetworkStakeStepRewardService = _ts_decorate8([
+  creatable8()
+], BaseNetworkStakeStepRewardService);
 
 // src/Schemas/BaseSchemasService.ts
-import { creatable as creatable12 } from "@xylabs/sdk-js";
-import { spanRootAsync as spanRootAsync4 } from "@xylabs/telemetry";
+import { creatable as creatable9 } from "@xylabs/sdk-js";
+import { spanRootAsync } from "@xylabs/telemetry";
 import { schemasSummary } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate12(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_decorate12, "_ts_decorate");
+__name(_ts_decorate9, "_ts_decorate");
 var BaseSchemasService = class extends BaseService {
   static {
     __name(this, "BaseSchemasService");
@@ -1394,8 +1897,8 @@ var BaseSchemasService = class extends BaseService {
     ]))[schema] ?? 0;
   }
   async schemas(head, schemas) {
-    return await spanRootAsync4("transfers", async () => {
-      const summary = await schemasSummary(this.params.context);
+    return await spanRootAsync("transfers", async () => {
+      const [summary] = await schemasSummary(this.params.context);
       const result = {};
       for (const schema of schemas) {
         const count = summary[schema] ?? 0;
@@ -1405,8 +1908,8 @@ var BaseSchemasService = class extends BaseService {
     });
   }
 };
-BaseSchemasService = _ts_decorate12([
-  creatable12()
+BaseSchemasService = _ts_decorate9([
+  creatable9()
 ], BaseSchemasService);
 
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
@@ -1436,21 +1939,21 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 }, "mapBoundWitnessToStakeIntentHashes");
 
 // src/StakeIntent/XyoStakeIntentService.ts
-import { asAddress, assertEx as assertEx13, creatable as creatable13, filterAs as filterAs3, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx19, creatable as creatable10, filterAs as filterAs3, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
 import { analyzeChain, ChainStakeIntentAnalyzer, isChainSummaryStakeIntent } from "@xyo-network/chain-analyze";
 import { DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS, findFirstMatching, IntervalMap } from "@xyo-network/chain-utils";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
 import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asChainStakeIntent as asChainStakeIntent2 } from "@xyo-network/xl1-protocol";
-import { asChainIndexingServiceStateWithStorageMeta, ChainIndexingServiceStateSchema, isChainIndexingServiceState, readPayloadMapFromStore as readPayloadMapFromStore2, timeBudget } from "@xyo-network/xl1-protocol-sdk";
+import { asChainIndexingServiceStateWithStorageMeta, ChainIndexingServiceStateSchema, isChainIndexingServiceState, readPayloadMapFromStore as readPayloadMapFromStore2, timeBudget as timeBudget5 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex3 } from "async-mutex";
 import { LRUCache as LRUCache2 } from "lru-cache";
-function _ts_decorate13(decorators, target, key, desc) {
+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_decorate13, "_ts_decorate");
+__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;
@@ -1472,36 +1975,41 @@ var XyoStakeIntentService = class extends BaseService {
     max: STAKE_CACHE_MAX_ENTRIES
   });
   _updateMutex = new Mutex3();
-  get chainArchivist() {
-    return assertEx13(this.params.chainArchivist, () => "chainArchivist not set");
+  get blockViewer() {
+    return this.params.blockViewer;
   }
-  get chainIterator() {
-    return assertEx13(this.params.chainIterator, () => "chainIterator not set");
+  get chainArchivist() {
+    return assertEx19(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainStakeViewer() {
-    return assertEx13(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx19(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx13(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx19(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+  }
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      blockViewer: assertEx19(params?.blockViewer, () => "blockViewer is required"),
+      chainArchivist: assertEx19(params?.chainArchivist, () => "chainArchivist is required"),
+      chainStakeViewer: assertEx19(params?.chainStakeViewer, () => "chainStakeViewer is required"),
+      stakeIntentStateArchivist: assertEx19(params?.stakeIntentStateArchivist, () => "stakeIntentStateArchivist is required")
+    };
   }
   async createHandler() {
-    this.chainIterator.on("headUpdated", async () => {
-      await this.updateIndex();
-    });
-    const head = await this.chainIterator.head();
+    const head = await this.blockViewer.currentBlock();
     if (isUndefined3(head)) return;
-    const headHash = await PayloadBuilder7.hash(head);
-    await this.recoverState(headHash);
+    await this.recoverState(head[0]._hash);
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx13(intent === "producer", () => `Support not yet added for intent ${intent}`);
+    assertEx19(intent === "producer", () => `Support not yet added for intent ${intent}`);
     const results = this._producers.get(address);
     return results ?? [];
   }
   async getDeclaredCandidatesForBlock(block, intent) {
     return await this.spanAsync("getDeclaredCandidatesForBlock", async () => {
-      assertEx13(intent === "producer", () => `Support not yet added for intent ${intent}`);
+      assertEx19(intent === "producer", () => `Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
       const candidates = [
         ...results
@@ -1555,7 +2063,7 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async persistState(current) {
     const state = this._producers.serialize();
-    const payload = new PayloadBuilder7({
+    const payload = new PayloadBuilder10({
       schema: ChainIndexingServiceStateSchema
     }).fields({
       endBlockHash: current,
@@ -1566,8 +2074,8 @@ var XyoStakeIntentService = class extends BaseService {
     ]);
   }
   async recoverState(current) {
-    return await timeBudget("XyoStakeIntentService.recoverState", console, async () => {
-      const currentBlock = assertEx13(asBlockBoundWitness3((await this.chainArchivist.get([
+    return await timeBudget5("XyoStakeIntentService.recoverState", console, async () => {
+      const currentBlock = assertEx19(asBlockBoundWitness3((await this.chainArchivist.get([
         current
       ]))?.[0]), () => `Block ${current} not found`);
       const currentBlockNum = currentBlock.block;
@@ -1607,9 +2115,9 @@ var XyoStakeIntentService = class extends BaseService {
     }
     await this._updateMutex.runExclusive(async () => {
       return await this.spanAsync("updateIndex", async () => {
-        const currentHead = await this.chainIterator.head();
+        const currentHead = (await this.blockViewer.currentBlock())[0];
         if (isUndefined3(currentHead)) return;
-        return await timeBudget("XyoStakeIntentService.updateIndex", console, async () => {
+        return await timeBudget5("XyoStakeIntentService.updateIndex", console, async () => {
           const currentHeadHash = currentHead._hash;
           const chainMap = readPayloadMapFromStore2(this.chainArchivist);
           const result = await analyzeChain({
@@ -1625,7 +2133,7 @@ var XyoStakeIntentService = class extends BaseService {
             const { exp, nbf } = signedDeclaration;
             const start = nbf;
             const stop = exp;
-            const address = asAddress(signedDeclaration?.from);
+            const address = asAddress2(signedDeclaration?.from);
             if (start !== void 0 && stop !== void 0 && address !== void 0) {
               this._producers.insert(address, start, stop);
             }
@@ -1636,87 +2144,35 @@ var XyoStakeIntentService = class extends BaseService {
     });
   }
 };
-XyoStakeIntentService = _ts_decorate13([
-  creatable13()
+XyoStakeIntentService = _ts_decorate10([
+  creatable10()
 ], XyoStakeIntentService);
 
 // src/StepStake/BaseStepStakeService.ts
-import { creatable as creatable14 } from "@xylabs/sdk-js";
-function _ts_decorate14(decorators, target, key, desc) {
+import { creatable as creatable11 } from "@xylabs/sdk-js";
+function _ts_decorate11(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate14, "_ts_decorate");
+__name(_ts_decorate11, "_ts_decorate");
 var BaseStepStakeService = class extends BaseService {
   static {
     __name(this, "BaseStepStakeService");
   }
   stepStake(_step) {
-    throw new Error("Method not implemented.");
+    throw new Error("Method [stepStake] not implemented.");
   }
   stepStakeForAddress(_address, _step) {
-    throw new Error("Method not implemented.");
+    throw new Error("Method [stepStakeForAddress] not implemented.");
   }
 };
-BaseStepStakeService = _ts_decorate14([
-  creatable14()
+BaseStepStakeService = _ts_decorate11([
+  creatable11()
 ], BaseStepStakeService);
-
-// src/Time/BaseTimeSyncService.ts
-import { creatable as creatable15 } from "@xylabs/sdk-js";
-import { SimpleTimeSyncViewer } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate15(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate15, "_ts_decorate");
-var BaseTimeSyncService = class extends BaseService {
-  static {
-    __name(this, "BaseTimeSyncService");
-  }
-  timeSyncViewer;
-  get chainArchivist() {
-    return this.params.chainArchivist;
-  }
-  get chainIterator() {
-    return this.params.chainIterator;
-  }
-  get ethProvider() {
-    return this.params.ethProvider;
-  }
-  async convertTime(fromDomain, toDomain, from) {
-    return await this.timeSyncViewer.convertTime(fromDomain, toDomain, from);
-  }
-  async createHandler() {
-    await super.createHandler();
-    const blockViewer = blockViewerFromChainIteratorAndArchivist(this.chainIterator, this.chainArchivist);
-    this.timeSyncViewer = new SimpleTimeSyncViewer(blockViewer, this.ethProvider);
-  }
-  async currentTime(domain) {
-    return await this.timeSyncViewer.currentTime(domain);
-  }
-  async currentTimeAndHash(domain) {
-    return await this.timeSyncViewer.currentTimeAndHash(domain);
-  }
-  async currentTimePayload() {
-    return await this.timeSyncViewer.currentTimePayload();
-  }
-};
-BaseTimeSyncService = _ts_decorate15([
-  creatable15()
-], BaseTimeSyncService);
 export {
-  BaseAccountBalanceService,
-  BaseAccountBalanceServiceParamsZod,
-  BaseAccountTransfersService,
   BaseAccountableService,
-  BaseBlockProducerService,
-  BaseBlockProducerServiceParamsZod,
-  BaseBlockRewardService,
   BaseElectionService,
   BaseNetworkStakeStepRewardService,
   BasePendingTransactionsService,
@@ -1726,17 +2182,34 @@ export {
   BaseTimeSyncService,
   ChainBlockNumberIterationService,
   DEFAULT_BLOCK_SIZE,
-  EvmBlockRewardService,
+  EvmBlockRewardViewer,
   EvmChainService,
-  MemoryBlockRewardService,
   MemoryChainService,
+  SimpleBlockRunner,
+  SimpleBlockRunnerParamsZod,
   XYO_PRODUCER_REDECLARATION_DURATION,
   XYO_PRODUCER_REDECLARATION_WINDOW,
   XyoStakeIntentService,
   XyoValidator,
-  accountBalancesServiceFromArchivist,
+  accountBalancesViewerFromArchivist,
   blockViewerFromChainIteratorAndArchivist,
+  canUseEvmProvider,
   creatableService,
-  getBlockSignedStakeDeclarations
+  getBlockSignedStakeDeclarations,
+  initAccountBalanceService,
+  initBlockProducer,
+  initBlockRewardViewer,
+  initBlockViewer,
+  initChainService,
+  initEvmBlockRewardViewer,
+  initEvmProvider,
+  initHead,
+  initMemoryChainService,
+  initMempoolRunner,
+  initMempoolViewer,
+  initPendingTransactions,
+  initTimeService,
+  initValidator,
+  initXyoBlockRewardViewer
 };
 //# sourceMappingURL=index.mjs.map