@xyo-network/chain-services 1.17.7 → 1.18.0-rc.1

package/dist/neutral/index.mjs

@@ -4,9 +4,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
 import { assertEx } from "@xylabs/sdk-js";
 import { StepSizes } from "@xyo-network/xl1-protocol";
-import { findMostRecentBlock, LruCacheMap, readPayloadMapFromStore, SimpleAccountBalanceViewer, SimpleBlockViewer } from "@xyo-network/xl1-protocol-sdk";
+import { findMostRecentBlock, LruCacheMap, payloadMapFromStore, SimpleAccountBalanceViewer } from "@xyo-network/xl1-protocol-sdk";
 import { Semaphore } from "async-mutex";
-var accountBalancesViewerFromArchivist = /* @__PURE__ */ __name(async (chainId, archivist) => {
+var accountBalancesViewerFromArchivist = /* @__PURE__ */ __name(async (context, chainId, archivist) => {
   const summaryMap = new LruCacheMap({
     max: 1e5,
     allowStale: true,
@@ -19,7 +19,7 @@ var accountBalancesViewerFromArchivist = /* @__PURE__ */ __name(async (chainId,
     noDisposeOnSet: false,
     updateAgeOnGet: true
   });
-  const chainMap = readPayloadMapFromStore(archivist);
+  const chainMap = payloadMapFromStore(archivist);
   const headFunc = /* @__PURE__ */ __name(async () => {
     const head = assertEx(await findMostRecentBlock(archivist), () => "No blocks found in chainArchivist");
     return [
@@ -28,14 +28,16 @@ var accountBalancesViewerFromArchivist = /* @__PURE__ */ __name(async (chainId,
     ];
   }, "headFunc");
   const service = await SimpleAccountBalanceViewer.create({
-    context: {
+    context,
+    balanceSummaryContext: {
       chainId,
       store: {
         chainMap
       },
       stepSemaphores: StepSizes.map(() => new Semaphore(20)),
       summaryMap,
-      head: headFunc
+      head: headFunc,
+      singletons: context.singletons
     },
     transfersSummaryContext: {
       chainId,
@@ -44,24 +46,16 @@ var accountBalancesViewerFromArchivist = /* @__PURE__ */ __name(async (chainId,
       },
       stepSemaphores: StepSizes.map(() => new Semaphore(20)),
       summaryMap: transferSummaryMap,
-      head: headFunc
-    },
-    blockViewer: await SimpleBlockViewer.create({
-      context: {
-        chainId,
-        head: headFunc,
-        store: {
-          chainMap
-        }
-      },
-      finalizedArchivist: archivist
-    })
+      head: headFunc,
+      singletons: context.singletons
+    }
   });
   return service;
 }, "accountBalancesViewerFromArchivist");
 
 // src/BaseService.ts
-import { AbstractCreatable, creatable } from "@xylabs/sdk-js";
+import { creatable } from "@xylabs/sdk-js";
+import { AbstractCreatableProvider } from "@xyo-network/xl1-protocol-sdk";
 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;
@@ -70,7 +64,7 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
-var BaseService = class extends AbstractCreatable {
+var BaseService = class extends AbstractCreatableProvider {
   static {
     __name(this, "BaseService");
   }
@@ -101,7 +95,7 @@ function creatableService() {
 __name(creatableService, "creatableService");
 
 // src/BlockReward/EvmBlockRewardViewer.ts
-import { AbstractCreatable as AbstractCreatable2, assertEx as assertEx2, creatable as creatable2, toEthAddress } from "@xylabs/sdk-js";
+import { AbstractCreatable, 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";
 import { BlockRewardViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
@@ -112,7 +106,7 @@ function _ts_decorate2(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate2, "_ts_decorate");
-var EvmBlockRewardViewer = class _EvmBlockRewardViewer extends AbstractCreatable2 {
+var EvmBlockRewardViewer = class _EvmBlockRewardViewer extends AbstractCreatable {
   static {
     __name(this, "EvmBlockRewardViewer");
   }
@@ -206,6 +200,13 @@ function blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist)
       }
       return results;
     }, "blocksByNumber"),
+    chainId: /* @__PURE__ */ __name(async function(blockNumber = "latest") {
+      const block = blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber);
+      if (!block) {
+        throw new Error(`Block not found for block number: ${blockNumber}`);
+      }
+      return block[0].chain;
+    }, "chainId"),
     currentBlock: /* @__PURE__ */ __name(async function() {
       const head = await chainIterator.head();
       return this.blockByHash(head._hash);
@@ -230,211 +231,56 @@ function blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist)
 }
 __name(blockViewerFromChainIteratorAndArchivist, "blockViewerFromChainIteratorAndArchivist");
 
-// 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, asBlockBoundWitnessWithStorageMeta, asSignedHydratedBlockWithHashMeta, asXL1BlockNumber, isBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
-import { BlockViewerMoniker as BlockViewerMoniker2, hydrateBlock } from "@xyo-network/xl1-protocol-sdk";
-import { LRUCache } from "lru-cache";
-var ChainBlockNumberIterationService = class _ChainBlockNumberIterationService extends BaseService {
-  static {
-    __name(this, "ChainBlockNumberIterationService");
-  }
-  static defaultMoniker = BlockViewerMoniker2;
-  static monikers = [
-    BlockViewerMoniker2
-  ];
-  moniker = _ChainBlockNumberIterationService.defaultMoniker;
-  _blocksByBlockNumber = new LRUCache({
-    max: 1e4
-  });
-  _currentHead;
-  get chainId() {
-    return assertEx3(this._currentHead?.chain ?? this.params?.head?.chain, () => "Current head is not set");
-  }
-  get chainMap() {
-    return assertEx3(this.params.chainMap);
-  }
-  get chainStoreRead() {
-    return {
-      chainMap: this.chainMap
-    };
-  }
-  async blockByHash(hash) {
-    return asSignedHydratedBlockWithHashMeta(await hydrateBlock(this.chainStoreRead, hash)) ?? null;
-  }
-  async blockByNumber(block) {
-    return asSignedHydratedBlockWithHashMeta(await this.get(block)) ?? null;
-  }
-  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;
-  }
-  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;
-  }
-  async currentBlock() {
-    return assertEx3(await this.blockByHash(await this.currentBlockHash()), () => "Current block not found");
-  }
-  async currentBlockHash() {
-    const head = assertEx3(await this.head(), () => "Head is not set");
-    return head._hash;
-  }
-  async currentBlockNumber() {
-    const head = assertEx3(await this.head(), () => "Head is not set");
-    return head.block;
-  }
-  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}`);
-  }
-  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");
-  }
-  async next(block) {
-    const currentBlock = block;
-    const nextBlockNumber = currentBlock + 1;
-    return await this.get(nextBlockNumber);
-  }
-  payloadByHash(_hash) {
-    throw new Error("Method [payloadByHash] not implemented.");
-  }
-  payloadsByHash(_hashes) {
-    throw new Error("Method [payloadsByHash] not implemented.");
-  }
-  // 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;
-  }
-  async updateHead(head) {
-    const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head);
-    this._currentHead = newHead;
-    void this.emit("headUpdated", {
-      blocks: [
-        newHead
-      ]
-    });
-  }
-  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;
-  }
-};
-
 // 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 { toAddress, toEthAddress as toEthAddress2 } from "@xylabs/sdk-js";
 import { ChainContractViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 import { getAddress } from "ethers/address";
-var EvmChainService = class _EvmChainService extends BaseService {
+var EvmChainViewer = class _EvmChainViewer extends BaseService {
   static {
-    __name(this, "EvmChainService");
+    __name(this, "EvmChainViewer");
   }
   static defaultMoniker = ChainContractViewerMoniker;
   static monikers = [
     ChainContractViewerMoniker
   ];
-  moniker = _EvmChainService.defaultMoniker;
+  moniker = _EvmChainViewer.defaultMoniker;
+  get contract() {
+    return this.params.contract;
+  }
   async active() {
-    return await (await this.contract()).active();
+    return await this.contract.active();
   }
   async activeByStaked(staked) {
-    return await (await this.contract()).activeByAddressStaked(getAddress(toEthAddress2(staked)));
+    return await this.contract.activeByAddressStaked(getAddress(toEthAddress2(staked)));
   }
   async activeByStaker(address) {
-    return await (await this.contract()).activeByStaker(getAddress(toEthAddress2(address)));
+    return await this.contract.activeByStaker(getAddress(toEthAddress2(address)));
   }
   async addStake(staked, amount) {
-    const result = await (await this.contract()).addStake(getAddress(toEthAddress2(staked)), amount);
+    const result = 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);
-    }
-    return assertEx4(this.params.contract);
-  }
   async forkedAtBlockNumber() {
-    return await (await this.contract()).forkedAtBlockNumber();
+    return await this.contract.forkedAtBlockNumber();
   }
   async forkedAtHash() {
-    return await (await this.contract()).forkedAtHash();
+    return await this.contract.forkedAtHash();
   }
   async forkedChainId() {
-    return toAddress(await (await this.contract()).forkedChainId());
+    return toAddress(await this.contract.forkedChainId());
   }
   async minWithdrawalBlocks() {
-    return await (await this.contract()).minWithdrawalBlocks();
+    return await this.contract.minWithdrawalBlocks();
   }
   async pending() {
-    return await (await this.contract()).pending();
+    return await this.contract.pending();
   }
   async pendingByStaker(staker) {
-    return await (await this.contract()).pendingByStaker(getAddress(toEthAddress2(staker)));
+    return await this.contract.pendingByStaker(getAddress(toEthAddress2(staker)));
   }
   async removeStake(slot) {
-    const result = await (await this.contract()).removeStake(slot);
+    const result = await this.contract.removeStake(slot);
     await result.wait();
     return true;
   }
@@ -442,36 +288,36 @@ var EvmChainService = class _EvmChainService extends BaseService {
     throw new Error("Method not implemented.");
   }
   async rewardsContract() {
-    return await (await this.contract()).rewardsContract();
+    return await this.contract.rewardsContract();
   }
   async stakingTokenAddress() {
-    return await (await this.contract()).stakingTokenAddress();
+    return await this.contract.stakingTokenAddress();
   }
   async withdrawStake(slot) {
-    const result = await (await this.contract()).withdrawStake(slot);
+    const result = await this.contract.withdrawStake(slot);
     await result.wait();
     return true;
   }
   async withdrawn() {
-    return await (await this.contract()).withdrawn();
+    return await this.contract.withdrawn();
   }
   async withdrawnByStaker(staker) {
-    return await (await this.contract()).withdrawnByStaker(getAddress(staker));
+    return await this.contract.withdrawnByStaker(getAddress(staker));
   }
 };
 
 // src/ChainService/Memory/Memory.ts
-import { assertEx as assertEx5, toAddress as toAddress2, ZERO_ADDRESS } from "@xylabs/sdk-js";
+import { toAddress as toAddress2, ZERO_ADDRESS } from "@xylabs/sdk-js";
 import { ChainContractViewerMoniker as ChainContractViewerMoniker2 } from "@xyo-network/xl1-protocol-sdk";
-var MemoryChainService = class _MemoryChainService extends BaseService {
+var MemoryChainViewer = class _MemoryChainViewer extends BaseService {
   static {
-    __name(this, "MemoryChainService");
+    __name(this, "MemoryChainViewer");
   }
   static defaultMoniker = ChainContractViewerMoniker2;
   static monikers = [
     ChainContractViewerMoniker2
   ];
-  moniker = _MemoryChainService.defaultMoniker;
+  moniker = _MemoryChainViewer.defaultMoniker;
   _chainId;
   _simulatedStake = 1n;
   async active() {
@@ -486,11 +332,8 @@ var MemoryChainService = class _MemoryChainService extends BaseService {
   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 ?? {};
+    const { minStake = 1 } = this.params.context.config.producer ?? {};
     this._simulatedStake = BigInt(minStake);
   }
   async forkedAtBlockNumber() {
@@ -539,7 +382,8 @@ var MemoryChainService = class _MemoryChainService extends BaseService {
 };
 
 // src/ChainValidator/XyoValidator.ts
-import { assertEx as assertEx6, creatable as creatable3 } from "@xylabs/sdk-js";
+import { creatable as creatable3 } from "@xylabs/sdk-js";
+import { BlockViewerMoniker as BlockViewerMoniker2 } 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);
@@ -551,6 +395,7 @@ var XyoValidator = class extends BaseService {
   static {
     __name(this, "XyoValidator");
   }
+  _blockViewer;
   // get address() {
   //   return this.account.address
   // }
@@ -558,7 +403,7 @@ var XyoValidator = class extends BaseService {
   //   return assertEx(this.params.account, () => 'account is required')
   // }
   get blockViewer() {
-    return assertEx6(this.params.blockViewer, () => "blockViewer is required");
+    return this._blockViewer;
   }
   // protected get chainInfo() {
   //   return assertEx(this.params.chainId, () => 'chainInfo is required')
@@ -572,6 +417,9 @@ var XyoValidator = class extends BaseService {
   // protected get blockRewardService() {
   //   return assertEx(this.params.blockRewardService, () => 'blockRewardService is required')
   // }
+  async createHandler() {
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker2);
+  }
   validatePendingBlock(_block) {
     return [];
   }
@@ -587,7 +435,7 @@ XyoValidator = _ts_decorate3([
 ], XyoValidator);
 
 // src/Election/BaseElectionService.ts
-import { assertEx as assertEx7, creatable as creatable4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx3, creatable as creatable4 } from "@xylabs/sdk-js";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
 function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -601,13 +449,13 @@ var BaseElectionService = class extends BaseService {
     __name(this, "BaseElectionService");
   }
   get blockViewer() {
-    return assertEx7(this.params.blockViewer, () => "No block viewer");
+    return assertEx3(this.params.blockViewer, () => "No block viewer");
   }
   get chainStakeViewer() {
-    return assertEx7(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx3(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx7(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx3(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
@@ -629,18 +477,20 @@ BaseElectionService = _ts_decorate4([
 ], BaseElectionService);
 
 // src/implementation/accountBalance.ts
-import { isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { AccountBalanceViewerRpcSchemas, HttpRpcTransport, JsonRpcAccountBalanceViewer } from "@xyo-network/xl1-rpc";
 var balanceServiceSingleton;
-var initAccountBalanceService = /* @__PURE__ */ __name((params) => {
+var initAccountBalanceService = /* @__PURE__ */ __name(async (params) => {
   const { config, logger } = params;
   if (balanceServiceSingleton) return balanceServiceSingleton;
   const endpoint = config.services?.accountBalanceViewerEndpoint ?? config.services?.apiEndpoint;
-  if (isDefined3(endpoint)) {
+  if (isDefined2(endpoint)) {
     const transport = new HttpRpcTransport(endpoint, {
       ...AccountBalanceViewerRpcSchemas
     });
-    const viewer = new JsonRpcAccountBalanceViewer(transport);
+    const viewer = await JsonRpcAccountBalanceViewer.create({
+      transport
+    });
     logger?.log("Using AccountBalanceViewer RPC service at", endpoint);
     return viewer;
   } else {
@@ -649,18 +499,19 @@ var initAccountBalanceService = /* @__PURE__ */ __name((params) => {
 }, "initAccountBalanceService");
 
 // src/implementation/blockViewer.ts
-import { isDefined as isDefined4 } from "@xylabs/sdk-js";
+import { isDefined as isDefined3 } 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;
+var initBlockViewer = /* @__PURE__ */ __name(async ({ config, logger }) => {
   if (blockViewerSingleton) return blockViewerSingleton;
   const endpoint = config.services?.apiEndpoint;
-  if (isDefined4(endpoint)) {
+  if (isDefined3(endpoint)) {
     const transport = new HttpRpcTransport2(endpoint, {
       ...BlockViewerRpcSchemas
     });
-    const viewer = new JsonRpcBlockViewer(transport);
+    const viewer = await JsonRpcBlockViewer.create({
+      transport
+    });
     logger?.log("Using BlockViewer RPC service at", endpoint);
     return viewer;
   } else {
@@ -669,26 +520,26 @@ var initBlockViewer = /* @__PURE__ */ __name((params) => {
 }, "initBlockViewer");
 
 // src/implementation/chain/index.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+import { assertEx as assertEx9 } 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 { asAddress, assertEx as assertEx8, isDefined as isDefined7, 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";
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
 
 // src/implementation/evm/initInfuraProvider.ts
-import { assertEx as assertEx9, isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5, isDefined as isDefined5 } 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";
+import { assertEx as assertEx4, hexFrom, isDefined as isDefined4, isHex } from "@xylabs/sdk-js";
 var canUseChainId = /* @__PURE__ */ __name((config) => {
-  return isDefined5(config.evm.chainId);
+  return isDefined4(config.evm.chainId);
 }, "canUseChainId");
 var getChainId = /* @__PURE__ */ __name((config) => {
-  const chainId = assertEx8(config.evm.chainId, () => "Missing config.evm.chainId");
+  const chainId = assertEx4(config.evm.chainId, () => "Missing config.evm.chainId");
   if (isHex(chainId, {
     prefix: true
   })) {
@@ -710,11 +561,11 @@ var initInfuraProvider = /* @__PURE__ */ __name((config) => {
   return instance;
 }, "initInfuraProvider");
 var canUseInfuraProvider = /* @__PURE__ */ __name((config) => {
-  return canUseChainId(config) && isDefined6(config.evm?.infura?.projectId) && isDefined6(config.evm?.infura?.projectSecret);
+  return canUseChainId(config) && isDefined5(config.evm?.infura?.projectId) && isDefined5(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");
+  const projectId = assertEx5(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx5(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
   return [
     getChainId(config),
     projectId,
@@ -723,17 +574,17 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
 }, "getInfuraProviderConfig");
 
 // src/implementation/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx10, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx6, isDefined as isDefined6 } 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);
+  return canUseChainId(config) && isDefined6(config.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
 var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config) => {
-  const jsonRpcUrl = assertEx10(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  const jsonRpcUrl = assertEx6(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
   return [
     jsonRpcUrl,
     getChainId(config)
@@ -749,7 +600,7 @@ var initEvmProvider = /* @__PURE__ */ __name(async ({ config }) => {
   } else if (canUseJsonRpcProvider(config)) {
     provider = initJsonRpcProvider(config);
   }
-  return assertEx11(await provider, () => "No provider available");
+  return assertEx7(await provider, () => "No provider available");
 }, "initEvmProvider");
 var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
@@ -759,20 +610,20 @@ var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
 var chainStakeServiceSingleton;
 var canUseEvmContractChainService = /* @__PURE__ */ __name((config) => {
   const { id } = config.chain;
-  return isDefined8(id) && id !== ZERO_ADDRESS2 && canUseEvmProvider({
+  return isDefined7(id) && id !== ZERO_ADDRESS2 && canUseEvmProvider({
     config
   });
 }, "canUseEvmContractChainService");
-var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, config, traceProvider, meterProvider, logger }) => {
+var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, context: { 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({
+  const emvStakingContractAddress = assertEx8(config.chain.id, () => "config.chain.id is required");
+  const id = assertEx8(asAddress(emvStakingContractAddress), () => "config.chain.id is not a valid address");
+  const provider2 = assertEx8(await initEvmProvider({
     config
   }));
-  const privateKey = assertEx12(account.private?.hex, () => "Account does not have a private key");
+  const privateKey = assertEx8(account.private?.hex, () => "Account does not have a private key");
   const runner = new Wallet(privateKey, provider2);
-  chainStakeServiceSingleton = EvmChainService.create({
+  chainStakeServiceSingleton = EvmChainViewer.create({
     id,
     runner,
     traceProvider,
@@ -786,27 +637,28 @@ var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, confi
 
 // src/implementation/chain/index.ts
 var chainStakeServiceSingleton2;
-var initChainService = /* @__PURE__ */ __name(({ account, config, logger }) => {
+var initChainService = /* @__PURE__ */ __name(({ account, context }) => {
+  const { logger } = context;
   logger?.log("ChainService: Initializing...");
   const result = init({
-    config,
+    context,
     name: "ChainService",
     account
   });
   logger?.log("ChainService: Initialized");
   return result;
 }, "initChainService");
-var initMemoryChainService = /* @__PURE__ */ __name(async ({ config }) => {
-  const result = await MemoryChainService.create({
-    config,
+var initMemoryChainService = /* @__PURE__ */ __name(async ({ context }) => {
+  const result = await MemoryChainViewer.create({
+    context,
     name: "MemoryChainService"
   });
-  assertEx13(await result.start(), () => "Failed to start MemoryChainService");
+  assertEx9(await result.start(), () => "Failed to start MemoryChainService");
   return result;
 }, "initMemoryChainService");
 var init = /* @__PURE__ */ __name(async (params) => {
   if (chainStakeServiceSingleton2) return chainStakeServiceSingleton2;
-  const { config } = params;
+  const { config } = params.context;
   chainStakeServiceSingleton2 = canUseEvmContractChainService(config) ? await initEvmContractChainService({
     ...params,
     name: "ChainStakeService"
@@ -814,16 +666,12 @@ var init = /* @__PURE__ */ __name(async (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();
+import { buildNextBlock, createGenesisBlock } from "@xyo-network/chain-protocol";
+import { createDeclarationIntent } from "@xyo-network/xl1-protocol-sdk";
+var createBootstrapHead = /* @__PURE__ */ __name(async (account, chainId, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
   const chain = [];
-  const genesisBlock = await createGenesisBlock(account, chainId, 10000000n, account.address);
+  const genesisBlock = await createGenesisBlock(account, chainId, genesisBlockRewardAmount, genesisBlockRewardAddress);
   chain.push(genesisBlock);
   const producerDeclarationPayload = createDeclarationIntent(account.address, "producer", genesisBlock[0].block, genesisBlock[0].block + 1e4);
   const producerDeclarationBlock = await buildNextBlock(genesisBlock[0], [], [
@@ -835,179 +683,6 @@ var createBootstrapHead = /* @__PURE__ */ __name(async (account, chainService) =
   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;
-      }
-    }
-  }
-}, "getForkFromBlock");
-
 // src/implementation/head/submitNewChain.ts
 import { delay } from "@xylabs/sdk-js";
 import { flattenHydratedBlock } from "@xyo-network/xl1-protocol-sdk";
@@ -1025,43 +700,21 @@ var submitNewChain = /* @__PURE__ */ __name(async (chain, chainArchivist, chainS
   }
 }, "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 { isDefined as isDefined8 } from "@xylabs/sdk-js";
 import { HttpRpcTransport as HttpRpcTransport3, JsonRpcMempoolRunner, MempoolRunnerRpcSchemas } from "@xyo-network/xl1-rpc";
 var mempoolRunnerSingleton;
-var initMempoolRunner = /* @__PURE__ */ __name((params) => {
+var initMempoolRunner = /* @__PURE__ */ __name(async (params) => {
   const { config, logger } = params;
   if (mempoolRunnerSingleton) return mempoolRunnerSingleton;
   const endpoint = config.services?.apiEndpoint;
-  if (isDefined11(endpoint)) {
+  if (isDefined8(endpoint)) {
     const transport = new HttpRpcTransport3(endpoint, {
       ...MempoolRunnerRpcSchemas
     });
-    const runner = new JsonRpcMempoolRunner(transport);
+    const runner = await JsonRpcMempoolRunner.create({
+      transport
+    });
     logger?.log("Using mempoolRunner RPC service at", endpoint);
     return runner;
   } else {
@@ -1070,18 +723,20 @@ var initMempoolRunner = /* @__PURE__ */ __name((params) => {
 }, "initMempoolRunner");
 
 // src/implementation/mempoolViewer.ts
-import { isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { isDefined as isDefined9 } from "@xylabs/sdk-js";
 import { HttpRpcTransport as HttpRpcTransport4, JsonRpcMempoolViewer, MempoolViewerRpcSchemas } from "@xyo-network/xl1-rpc";
 var mempoolViewerSingleton;
-var initMempoolViewer = /* @__PURE__ */ __name((params) => {
+var initMempoolViewer = /* @__PURE__ */ __name(async (params) => {
   const { config, logger } = params;
   if (mempoolViewerSingleton) return mempoolViewerSingleton;
   const endpoint = config.services?.apiEndpoint;
-  if (isDefined12(endpoint)) {
+  if (isDefined9(endpoint)) {
     const transport = new HttpRpcTransport4(endpoint, {
       ...MempoolViewerRpcSchemas
     });
-    const viewer = new JsonRpcMempoolViewer(transport);
+    const viewer = await JsonRpcMempoolViewer.create({
+      transport
+    });
     logger?.log("Using MempoolViewer RPC service at", endpoint);
     return viewer;
   } else {
@@ -1090,24 +745,24 @@ var initMempoolViewer = /* @__PURE__ */ __name((params) => {
 }, "initMempoolViewer");
 
 // src/implementation/pendingTransactions.ts
-import { isDefined as isDefined14 } from "@xylabs/sdk-js";
+import { isDefined as isDefined11 } 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 assertEx15, creatable as creatable5, exists, filterAs, filterAsync, forget, isDefined as isDefined13, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, creatable as creatable5, exists, filterAs, filterAsync, forget, isDefined as isDefined10, isUndefined } from "@xylabs/sdk-js";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { asBlockBoundWitnessWithHashMeta, asXL1BlockNumber as asXL1BlockNumber2, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
-import { findMostRecentBlock as findMostRecentBlock3, MempoolViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+import { asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { findMostRecentBlock as findMostRecentBlock2, MempoolViewerMoniker } 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 PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 import { asSignedTransactionBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withHashMeta = await PayloadBuilder6.addHashMeta(payload.payloads);
+  const withHashMeta = await PayloadBuilder2.addHashMeta(payload.payloads);
   const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
@@ -1118,7 +773,7 @@ var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload)
 }, "bundledPayloadToHydratedTransaction");
 
 // src/PendingTransactions/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder3 } 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) => {
@@ -1126,8 +781,8 @@ var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) =>
   return bundle(root, transaction);
 }, "hydratedTransactionToPayloadBundle");
 var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder7.omitStorageMeta(p));
-  return new PayloadBuilder7({
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder3.omitStorageMeta(p));
+  return new PayloadBuilder3({
     schema: PayloadBundleSchema
   }).fields({
     payloads,
@@ -1195,23 +850,20 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
     return this.params.additionalPendingTransactionValidators ?? [];
   }
   get chainArchivist() {
-    return assertEx15(this.params.chainArchivist, () => "No completed blocks with data archivist");
-  }
-  get chainId() {
-    return assertEx15(this.params.chainId, () => "No chain id");
+    return assertEx10(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx15(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx10(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx15(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+    return assertEx10(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");
+    return assertEx10(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
@@ -1247,7 +899,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         let lastHead = filterAs(await this.chainArchivist.next({
           limit: 100
         }), (x) => asBlockBoundWitnessWithHashMeta(x)).at(-1);
-        if (isUndefined2(lastHead)) return [];
+        if (isUndefined(lastHead)) return [];
         await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
         const foundPendingTransactions = [];
         let cursor;
@@ -1261,11 +913,11 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           cursor = pendingBundledTransactions.at(-1)?._sequence;
           const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
           const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists);
-          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber2(lastHead.block + 1, true)));
+          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
+              chainId: this.params.chainId
             }, this.additionalPendingTransactionValidators)
           ]));
           const validTransactions = txValidationResults.filter(([, errors]) => errors.length === 0).map(([tx]) => tx);
@@ -1290,8 +942,8 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
   }
   async cleanupWorker() {
     return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-      const lastHead = await findMostRecentBlock3(this.chainArchivist);
-      if (isDefined13(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
+      const lastHead = await findMostRecentBlock2(this.chainArchivist);
+      if (isDefined10(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
     }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
   }
   async countPendingTransactions() {
@@ -1318,7 +970,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         }))).filter(exists);
         const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
           const errors = await validateTransaction(tx, {
-            chainId: this.chainId
+            chainId: this.params.chainId
           }, [
             TransactionJsonSchemaValidator
           ]);
@@ -1353,7 +1005,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       let [lastHead] = filterAs(await this.chainArchivist.get([
         head
       ]), (x) => asBlockBoundWitnessWithHashMeta(x));
-      while (isDefined13(lastHead)) {
+      while (isDefined10(lastHead)) {
         const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
           limit: 100,
           order: "asc",
@@ -1367,7 +1019,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         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 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
@@ -1399,11 +1051,13 @@ var initPendingTransactions = /* @__PURE__ */ __name(async ({ config, params, lo
   if (serviceSingleton) return serviceSingleton;
   return await timeBudget("initPendingTransactions", logger, async () => {
     const endpoint = config.services?.apiEndpoint;
-    if (isDefined14(endpoint)) {
+    if (isDefined11(endpoint)) {
       const transport = new HttpRpcTransport5(endpoint, {
         ...MempoolViewerRpcSchemas2
       });
-      const viewer = new JsonRpcMempoolViewer2(transport);
+      const viewer = await JsonRpcMempoolViewer2.create({
+        transport
+      });
       logger?.log("Using MempoolViewer RPC service at", endpoint);
       return viewer;
     } else {
@@ -1413,30 +1067,177 @@ var initPendingTransactions = /* @__PURE__ */ __name(async ({ config, params, lo
   }, 2e3, true);
 }, "initPendingTransactions");
 
-// src/implementation/producer.ts
-import { timeBudget as timeBudget2 } from "@xyo-network/xl1-protocol-sdk";
+// src/implementation/reward.ts
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { SimpleBlockRewardViewer, timeBudget as timeBudget2 } from "@xyo-network/xl1-protocol-sdk";
+var rewardServiceSingleton;
+var initBlockRewardViewer = /* @__PURE__ */ __name((params) => {
+  if (rewardServiceSingleton) return rewardServiceSingleton;
+  return timeBudget2("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 timeBudget2("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 timeBudget2("initEvmBlockRewardViewer", params.logger, async () => {
+    const provider2 = assertEx11(await initEvmProvider(params));
+    const evmBlockRewardViewerParams = {
+      ...params,
+      provider: provider2
+    };
+    rewardServiceSingleton = EvmBlockRewardViewer.create(evmBlockRewardViewerParams);
+    return rewardServiceSingleton;
+  }, 2e3, true);
+}, "initEvmBlockRewardViewer");
+
+// src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts
+import { creatable as creatable6 } from "@xylabs/sdk-js";
+import { NetworkStakeStepRewardViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+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 BaseNetworkStakeStepRewardService = class _BaseNetworkStakeStepRewardService extends BaseService {
+  static {
+    __name(this, "BaseNetworkStakeStepRewardService");
+  }
+  static defaultMoniker = NetworkStakeStepRewardViewerMoniker;
+  static monikers = [
+    NetworkStakeStepRewardViewerMoniker
+  ];
+  moniker = _BaseNetworkStakeStepRewardService.defaultMoniker;
+  networkStakeStepRewardAddressHistory(_address) {
+    throw new Error("Method [networkStakeStepRewardAddressHistory] not implemented.");
+  }
+  networkStakeStepRewardAddressReward(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardAddressReward] not implemented.");
+  }
+  networkStakeStepRewardAddressShare(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardAddressShare] not implemented.");
+  }
+  networkStakeStepRewardClaimedByAddress(_address) {
+    throw new Error("Method [networkStakeStepRewardClaimedByAddress] not implemented.");
+  }
+  networkStakeStepRewardForPosition(_position, _range) {
+    throw new Error("Method [networkStakeStepRewardForPosition] not implemented.");
+  }
+  networkStakeStepRewardForStep(_context) {
+    throw new Error("Method [networkStakeStepRewardForStep] not implemented.");
+  }
+  networkStakeStepRewardForStepForPosition(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardForStepForPosition] not implemented.");
+  }
+  networkStakeStepRewardPoolRewards(_context) {
+    throw new Error("Method [networkStakeStepRewardPoolRewards] not implemented.");
+  }
+  networkStakeStepRewardPoolShares(_context) {
+    throw new Error("Method [networkStakeStepRewardPoolShares] not implemented.");
+  }
+  networkStakeStepRewardPositionWeight(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardPositionWeight] not implemented.");
+  }
+  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardPotentialPositionLoss] not implemented.");
+  }
+  networkStakeStepRewardRandomizer(_context) {
+    throw new Error("Method [networkStakeStepRewardRandomizer] not implemented.");
+  }
+  networkStakeStepRewardStakerCount(_context) {
+    throw new Error("Method [networkStakeStepRewardStakerCount] not implemented.");
+  }
+  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.");
+  }
+};
+BaseNetworkStakeStepRewardService = _ts_decorate6([
+  creatable6()
+], BaseNetworkStakeStepRewardService);
+
+// src/Schemas/BaseSchemasService.ts
+import { creatable as creatable7, spanRootAsync } from "@xylabs/sdk-js";
+import { schemasSummary } 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 BaseSchemasService = class extends BaseService {
+  static {
+    __name(this, "BaseSchemasService");
+  }
+  async schema(head, schema) {
+    return (await this.schemas(head, [
+      schema
+    ]))[schema] ?? 0;
+  }
+  async schemas(head, schemas) {
+    return await spanRootAsync("transfers", async () => {
+      const [summary] = await schemasSummary(this.params.schemasStepSummaryContext);
+      const result = {};
+      for (const schema of schemas) {
+        const count = summary[schema] ?? 0;
+        result[schema] = count;
+      }
+      return result;
+    });
+  }
+};
+BaseSchemasService = _ts_decorate7([
+  creatable7()
+], BaseSchemasService);
 
 // 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 { assertEx as assertEx13, exists as exists2, hexToBigInt, isDefined as isDefined12 } 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";
+import { buildNextBlock as buildNextBlock2 } from "@xyo-network/chain-protocol";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness, AttoXL1, BlockNumberSchema, defaultRewardRatio, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
+import { AbstractCreatableProvider as AbstractCreatableProvider2, AccountBalanceViewerMoniker, BlockRewardViewerMoniker as BlockRewardViewerMoniker2, BlockRunnerMoniker, creatableProvider, createDeclarationIntent as createDeclarationIntent2, MempoolRunnerMoniker, MempoolViewerMoniker as MempoolViewerMoniker2, TimeSyncViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // 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 { hexFromBigInt } from "@xylabs/sdk-js";
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder4 } 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])
+      await PayloadBuilder4.addStorageMeta(tx[0]),
+      await PayloadBuilder4.addStorageMeta(tx[1])
     ]);
   }));
   const txBaseFeeCosts = {};
@@ -1456,49 +1257,50 @@ async function generateTransactionFeeTransfers(address, transactions) {
       from,
       transfers: {
         // burn the base fee
-        [XYO_ZERO_ADDRESS]: hexFromBigInt2(amount)
+        [XYO_ZERO_ADDRESS]: hexFromBigInt(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);
+    const fromPayload = assertEx12(payloads.find((p) => p.from === from), () => "from payload not found");
+    fromPayload.transfers[address] = hexFromBigInt(amount);
   }
   return payloads;
 }
 __name(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
 
 // src/simple/block/runner/SimpleBlockRunner.ts
-function _ts_decorate6(decorators, target, key, desc) {
+function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate6, "_ts_decorate");
+__name(_ts_decorate8, "_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 {
+var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvider2 {
   static {
     __name(this, "SimpleBlockRunner");
   }
+  static defaultMoniker = BlockRunnerMoniker;
+  static monikers = [
+    BlockRunnerMoniker
+  ];
+  moniker = _SimpleBlockRunner.defaultMoniker;
   _blockRewardDiviner;
   _lastRedeclarationBlock;
   _rejectedTransactionsArchivist;
+  _account;
+  _accountBalanceViewer;
+  _address;
+  _blockRewardViewer;
+  _mempoolRunner;
+  _mempoolViewer;
+  _rewardAddress;
+  _timeSyncViewer;
   /**
   * The default block size for a block
   */
@@ -1519,29 +1321,26 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
   static get RedeclarationWindow() {
     return XYO_PRODUCER_REDECLARATION_WINDOW;
   }
-  get address() {
-    return this.account.address;
-  }
   get account() {
-    return assertEx17(this.params.account, () => "account is required");
+    return this._account;
   }
-  get balanceViewer() {
-    return assertEx17(this.params.balanceViewer, () => "balanceViewer is required");
+  get accountBalanceViewer() {
+    return this._accountBalanceViewer;
   }
-  get blockRewardViewer() {
-    return assertEx17(this.params.blockRewardViewer, () => "blockRewardViewer is required");
+  get address() {
+    return this._address;
   }
-  get chainId() {
-    return assertEx17(this.params.chainId, () => "chainId is required");
+  get blockRewardViewer() {
+    return this._blockRewardViewer;
   }
   // protected get electionService() {
   //   return assertEx(this.params.electionService, () => 'electionService is required')
   // }
   get mempoolRunner() {
-    return assertEx17(this.params.mempoolRunner, () => "mempoolRunner is required");
+    return this._mempoolRunner;
   }
   get mempoolViewer() {
-    return assertEx17(this.params.mempoolViewer, () => "mempoolViewer is required");
+    return this._mempoolViewer;
   }
   // protected get pendingTransactionsService() {
   //   return assertEx(this.params.pendingTransactionsService, () => 'Missing pendingTransactionsService')
@@ -1550,34 +1349,34 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
     return this._rejectedTransactionsArchivist;
   }
   get rewardAddress() {
-    return assertEx17(this.params.rewardAddress, () => "No reward address provided");
+    return assertEx13(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");
+  get timeSyncViewer() {
+    return this._timeSyncViewer;
   }
   // 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 createHandler() {
+    this._rejectedTransactionsArchivist = this.params.rejectedTransactionsArchivist ?? await MemoryArchivist2.create();
+    this._account = assertEx13(this.params.account, () => "Account is required");
+    this._rewardAddress = assertEx13(this.params.rewardAddress, () => "No reward address provided");
+    this._address = this.account.address;
+    this._accountBalanceViewer = await this.locateAndCreate(AccountBalanceViewerMoniker);
+    this._blockRewardViewer = await this.locateAndCreate(BlockRewardViewerMoniker2);
+    this._mempoolRunner = await this.locateAndCreate(MempoolRunnerMoniker);
+    this._mempoolViewer = await this.locateAndCreate(MempoolViewerMoniker2);
+    this._timeSyncViewer = await this.locateAndCreate(TimeSyncViewerMoniker);
   }
   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;
+    return force ? assertEx13(result, () => "Failed to produce next block") : result;
   }
   async getBlockRewardTransfers(block) {
     if (!this._blockRewardDiviner) {
@@ -1591,7 +1390,7 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
         }
       });
     }
-    const blockId = new PayloadBuilder9({
+    const blockId = new PayloadBuilder5({
       schema: BlockNumberSchema
     }).fields({
       block
@@ -1607,50 +1406,49 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
   * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
   */
   getProducerRedeclaration(head) {
-    if (this.params.config.producer.disableIntentRedeclaration) return;
+    if (this.params.context.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 (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`);
+      try {
+        const { block: previousBlock } = assertEx13(asBlockBoundWitness(head), () => "Invalid head block");
+        const nextBlock = previousBlock + 1;
+        const nextBlockTransactions = await this.mempoolViewer.pendingTransactions({
+          limit: _SimpleBlockRunner.DefaultBlockSize
+        });
+        this.logger?.info(`Pending Tx Count ${nextBlockTransactions.length}`);
+        const blockPayloads = [];
+        const producerRedeclarationPayload = await this.getProducerRedeclaration(head);
+        if (producerRedeclarationPayload) blockPayloads.push(producerRedeclarationPayload);
+        if (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.accountBalanceViewer.accountBalances([
+          XYO_STEP_REWARD_ADDRESS
+        ]))[XYO_STEP_REWARD_ADDRESS];
+        const block = await buildNextBlock2(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`);
+        await this.mempoolRunner.submitBlocks([
+          block
+        ]);
+        return block;
+      } catch {
       }
-      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
@@ -1661,9 +1459,9 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
       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([
+        const balance = (await this.accountBalanceViewer.accountBalances([
           transfer.from
-        ]))[transfer.from] ?? AttoXL12(0n);
+        ]))[transfer.from] ?? AttoXL1(0n);
         if (balance >= totalTransferCost) {
           fundedTransfers.push(transfer);
           return tx;
@@ -1679,19 +1477,7 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
     ];
   }
   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;
+    return await this.timeSyncViewer.currentTimePayload();
   }
   /**
   * Check if a heartbeat block is required based on network activity.
@@ -1700,8 +1486,8 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
   */
   heartbeatRequired(head) {
     const epoch = head.$epoch;
-    if (isDefined15(epoch)) {
-      const { heartbeatInterval } = this.params.config.producer;
+    if (isDefined12(epoch)) {
+      const { heartbeatInterval } = this.params.context.config.producer;
       if (Date.now() - epoch > heartbeatInterval) {
         return true;
       }
@@ -1709,252 +1495,10 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatable3 {
     return false;
   }
 };
-SimpleBlockRunner = _ts_decorate6([
-  creatable6()
+SimpleBlockRunner = _ts_decorate8([
+  creatableProvider()
 ], 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, TimeSyncViewerMoniker } 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 _BaseTimeSyncService extends BaseService {
-  static {
-    __name(this, "BaseTimeSyncService");
-  }
-  static defaultMoniker = TimeSyncViewerMoniker;
-  static monikers = [
-    TimeSyncViewerMoniker
-  ];
-  moniker = _BaseTimeSyncService.defaultMoniker;
-  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 = await SimpleTimeSyncViewer.create({
-      blockViewer: this.blockViewer,
-      ethProvider: 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";
-import { NetworkStakeStepRewardViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
-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 _BaseNetworkStakeStepRewardService extends BaseService {
-  static {
-    __name(this, "BaseNetworkStakeStepRewardService");
-  }
-  static defaultMoniker = NetworkStakeStepRewardViewerMoniker;
-  static monikers = [
-    NetworkStakeStepRewardViewerMoniker
-  ];
-  moniker = _BaseNetworkStakeStepRewardService.defaultMoniker;
-  networkStakeStepRewardAddressHistory(_address) {
-    throw new Error("Method [networkStakeStepRewardAddressHistory] not implemented.");
-  }
-  networkStakeStepRewardAddressReward(_context, _address) {
-    throw new Error("Method [networkStakeStepRewardAddressReward] not implemented.");
-  }
-  networkStakeStepRewardAddressShare(_context, _address) {
-    throw new Error("Method [networkStakeStepRewardAddressShare] not implemented.");
-  }
-  networkStakeStepRewardClaimedByAddress(_address) {
-    throw new Error("Method [networkStakeStepRewardClaimedByAddress] not implemented.");
-  }
-  networkStakeStepRewardForPosition(_position, _range) {
-    throw new Error("Method [networkStakeStepRewardForPosition] not implemented.");
-  }
-  networkStakeStepRewardForStep(_context) {
-    throw new Error("Method [networkStakeStepRewardForStep] not implemented.");
-  }
-  networkStakeStepRewardForStepForPosition(_context, _position) {
-    throw new Error("Method [networkStakeStepRewardForStepForPosition] not implemented.");
-  }
-  networkStakeStepRewardPoolRewards(_context) {
-    throw new Error("Method [networkStakeStepRewardPoolRewards] not implemented.");
-  }
-  networkStakeStepRewardPoolShares(_context) {
-    throw new Error("Method [networkStakeStepRewardPoolShares] not implemented.");
-  }
-  networkStakeStepRewardPositionWeight(_context, _position) {
-    throw new Error("Method [networkStakeStepRewardPositionWeight] not implemented.");
-  }
-  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
-    throw new Error("Method [networkStakeStepRewardPotentialPositionLoss] not implemented.");
-  }
-  networkStakeStepRewardRandomizer(_context) {
-    throw new Error("Method [networkStakeStepRewardRandomizer] not implemented.");
-  }
-  networkStakeStepRewardStakerCount(_context) {
-    throw new Error("Method [networkStakeStepRewardStakerCount] not implemented.");
-  }
-  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.");
-  }
-};
-BaseNetworkStakeStepRewardService = _ts_decorate8([
-  creatable8()
-], BaseNetworkStakeStepRewardService);
-
-// src/Schemas/BaseSchemasService.ts
-import { creatable as creatable9, spanRootAsync } from "@xylabs/sdk-js";
-import { schemasSummary } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate9(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate9, "_ts_decorate");
-var BaseSchemasService = class extends BaseService {
-  static {
-    __name(this, "BaseSchemasService");
-  }
-  async schema(head, schema) {
-    return (await this.schemas(head, [
-      schema
-    ]))[schema] ?? 0;
-  }
-  async schemas(head, schemas) {
-    return await spanRootAsync("transfers", async () => {
-      const [summary] = await schemasSummary(this.params.context);
-      const result = {};
-      for (const schema of schemas) {
-        const count = summary[schema] ?? 0;
-        result[schema] = count;
-      }
-      return result;
-    });
-  }
-};
-BaseSchemasService = _ts_decorate9([
-  creatable9()
-], BaseSchemasService);
-
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
 import { exists as exists3, filterAs as filterAs2 } from "@xylabs/sdk-js";
 import { isBoundWitness } from "@xyo-network/boundwitness-model";
@@ -1982,21 +1526,21 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 }, "mapBoundWitnessToStakeIntentHashes");
 
 // src/StakeIntent/XyoStakeIntentService.ts
-import { asAddress as asAddress2, assertEx as assertEx19, creatable as creatable10, filterAs as filterAs3, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx14, creatable as creatable8, filterAs as filterAs3, isUndefined as isUndefined2 } 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 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 as timeBudget5 } from "@xyo-network/xl1-protocol-sdk";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta, asChainStakeIntent as asChainStakeIntent2 } from "@xyo-network/xl1-protocol";
+import { asChainIndexingServiceStateWithStorageMeta, BlockViewerMoniker as BlockViewerMoniker3, ChainIndexingServiceStateSchema, ChainStakeViewerMoniker, isChainIndexingServiceState, readPayloadMapFromStore, timeBudget as timeBudget3 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex3 } from "async-mutex";
-import { LRUCache as LRUCache2 } from "lru-cache";
-function _ts_decorate10(decorators, target, key, desc) {
+import { LRUCache } from "lru-cache";
+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_decorate10, "_ts_decorate");
+__name(_ts_decorate9, "_ts_decorate");
 var ACTIVE_STAKE_TTL = 1e3 * 60 * 60 * 2;
 var NO_ACTIVE_STAKE_TTL = 1e3 * 2;
 var STAKE_CACHE_MAX_ENTRIES = 1e4;
@@ -2014,45 +1558,47 @@ var XyoStakeIntentService = class extends BaseService {
   // in performance for small sets, and (most importantly) easily
   // persisted so we can recover state on restart.
   _producers = new IntervalMap();
-  _stakeCache = new LRUCache2({
+  _stakeCache = new LRUCache({
     max: STAKE_CACHE_MAX_ENTRIES
   });
   _updateMutex = new Mutex3();
+  _blockViewer;
+  _chainStakeViewer;
   get blockViewer() {
-    return this.params.blockViewer;
+    return this._blockViewer;
   }
   get chainArchivist() {
-    return assertEx19(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx14(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainStakeViewer() {
-    return assertEx19(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return this._chainStakeViewer;
   }
   get stakeIntentStateArchivist() {
-    return assertEx19(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx14(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")
+      chainArchivist: assertEx14(params?.chainArchivist, () => "chainArchivist is required"),
+      stakeIntentStateArchivist: assertEx14(params?.stakeIntentStateArchivist, () => "stakeIntentStateArchivist is required")
     };
   }
   async createHandler() {
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker3);
+    this._chainStakeViewer = await this.locator.getInstance(ChainStakeViewerMoniker);
     const head = await this.blockViewer.currentBlock();
-    if (isUndefined3(head)) return;
+    if (isUndefined2(head)) return;
     await this.recoverState(head[0]._hash);
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx19(intent === "producer", () => `Support not yet added for intent ${intent}`);
+    assertEx14(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 () => {
-      assertEx19(intent === "producer", () => `Support not yet added for intent ${intent}`);
+      assertEx14(intent === "producer", () => `Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
       const candidates = [
         ...results
@@ -2065,7 +1611,7 @@ var XyoStakeIntentService = class extends BaseService {
   getRequiredMinimumStakeForIntent(intent) {
     switch (intent) {
       case "producer": {
-        const { minStake } = this.params.config.producer;
+        const { minStake } = this.params.context.config.producer;
         return BigInt(minStake);
       }
     }
@@ -2106,7 +1652,7 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async persistState(current) {
     const state = this._producers.serialize();
-    const payload = new PayloadBuilder10({
+    const payload = new PayloadBuilder6({
       schema: ChainIndexingServiceStateSchema
     }).fields({
       endBlockHash: current,
@@ -2117,8 +1663,8 @@ var XyoStakeIntentService = class extends BaseService {
     ]);
   }
   async recoverState(current) {
-    return await timeBudget5("XyoStakeIntentService.recoverState", console, async () => {
-      const currentBlock = assertEx19(asBlockBoundWitness3((await this.chainArchivist.get([
+    return await timeBudget3("XyoStakeIntentService.recoverState", console, async () => {
+      const currentBlock = assertEx14(asBlockBoundWitness2((await this.chainArchivist.get([
         current
       ]))?.[0]), () => `Block ${current} not found`);
       const currentBlockNum = currentBlock.block;
@@ -2135,7 +1681,7 @@ var XyoStakeIntentService = class extends BaseService {
           const indexed = (await this.chainArchivist.get([
             state.endBlockHash
           ]))?.[0];
-          const indexedBlock = asBlockBoundWitnessWithStorageMeta2(indexed);
+          const indexedBlock = asBlockBoundWitnessWithStorageMeta(indexed);
           if (indexedBlock) {
             const indexedBlockNum = indexedBlock.block;
             if (indexedBlockNum <= currentBlockNum) {
@@ -2159,10 +1705,10 @@ var XyoStakeIntentService = class extends BaseService {
     await this._updateMutex.runExclusive(async () => {
       return await this.spanAsync("updateIndex", async () => {
         const currentHead = (await this.blockViewer.currentBlock())[0];
-        if (isUndefined3(currentHead)) return;
-        return await timeBudget5("XyoStakeIntentService.updateIndex", console, async () => {
+        if (isUndefined2(currentHead)) return;
+        return await timeBudget3("XyoStakeIntentService.updateIndex", console, async () => {
           const currentHeadHash = currentHead._hash;
-          const chainMap = readPayloadMapFromStore2(this.chainArchivist);
+          const chainMap = readPayloadMapFromStore(this.chainArchivist);
           const result = await analyzeChain({
             chainMap
           }, [
@@ -2187,20 +1733,20 @@ var XyoStakeIntentService = class extends BaseService {
     });
   }
 };
-XyoStakeIntentService = _ts_decorate10([
-  creatable10()
+XyoStakeIntentService = _ts_decorate9([
+  creatable8()
 ], XyoStakeIntentService);
 
 // src/StepStake/BaseStepStakeService.ts
-import { creatable as creatable11 } from "@xylabs/sdk-js";
+import { creatable as creatable9 } from "@xylabs/sdk-js";
 import { StepStakeViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate11(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_decorate11, "_ts_decorate");
+__name(_ts_decorate10, "_ts_decorate");
 var BaseStepStakeService = class _BaseStepStakeService extends BaseService {
   static {
     __name(this, "BaseStepStakeService");
@@ -2217,8 +1763,8 @@ var BaseStepStakeService = class _BaseStepStakeService extends BaseService {
     throw new Error("Method [stepStakeForAddress] not implemented.");
   }
 };
-BaseStepStakeService = _ts_decorate11([
-  creatable11()
+BaseStepStakeService = _ts_decorate10([
+  creatable9()
 ], BaseStepStakeService);
 export {
   BaseAccountableService,
@@ -2228,14 +1774,11 @@ export {
   BaseSchemasService,
   BaseService,
   BaseStepStakeService,
-  BaseTimeSyncService,
-  ChainBlockNumberIterationService,
   DEFAULT_BLOCK_SIZE,
   EvmBlockRewardViewer,
-  EvmChainService,
-  MemoryChainService,
+  EvmChainViewer,
+  MemoryChainViewer,
   SimpleBlockRunner,
-  SimpleBlockRunnerParamsZod,
   XYO_PRODUCER_REDECLARATION_DURATION,
   XYO_PRODUCER_REDECLARATION_WINDOW,
   XyoStakeIntentService,
@@ -2244,21 +1787,19 @@ export {
   blockViewerFromChainIteratorAndArchivist,
   canUseEvmProvider,
   creatableService,
+  createBootstrapHead,
   getBlockSignedStakeDeclarations,
   initAccountBalanceService,
-  initBlockProducer,
   initBlockRewardViewer,
   initBlockViewer,
   initChainService,
   initEvmBlockRewardViewer,
   initEvmProvider,
-  initHead,
   initMemoryChainService,
   initMempoolRunner,
   initMempoolViewer,
   initPendingTransactions,
-  initTimeService,
-  initValidator,
-  initXyoBlockRewardViewer
+  initXyoBlockRewardViewer,
+  submitNewChain
 };
 //# sourceMappingURL=index.mjs.map