@xyo-network/xl1-providers 4.0.6 → 4.0.7

package/dist/neutral/index.mjs

@@ -11,16 +11,17 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/buildSimpleXyoSignerV2.ts
+// src/buildSimpleXyoSigner.ts
 import { XyoSignerMoniker } from "@xyo-network/xl1-protocol-lib";
 import { ProviderFactoryLocator, SimpleXyoSigner } from "@xyo-network/xl1-protocol-sdk";
-async function buildSimpleXyoSignerV2(context, account) {
+async function buildSimpleXyoSigner(context, account) {
   const locator = new ProviderFactoryLocator(context);
   locator.register(
     SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, { account })
   );
   return await locator.getInstance(XyoSignerMoniker);
 }
+var buildSimpleXyoSignerV2 = buildSimpleXyoSigner;
 
 // src/creators/createRestDataLake.ts
 import { RestDataLakeRunner as RestDataLakeRunner3, RestDataLakeViewer as RestDataLakeViewer4 } from "@xyo-network/xl1-protocol-sdk";
@@ -40,7 +41,7 @@ async function baseConfigFactoryLocator() {
 }
 
 // src/locators/basicRemoteRunnerLocator.ts
-import { isDefined as isDefined3 } from "@xylabs/sdk";
+import { isDefined as isDefined3 } from "@ariestools/sdk";
 import {
   ProviderFactoryLocator as ProviderFactoryLocator4,
   RestDataLakeRunner as RestDataLakeRunner2,
@@ -95,7 +96,7 @@ SimpleXyoConnectionRunner = __decorateClass([
 ], SimpleXyoConnectionRunner);
 
 // src/locators/basicRemoteViewerLocator.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk";
+import { isDefined as isDefined2 } from "@ariestools/sdk";
 import {
   ActorConfigZod,
   RestDataLakeViewer as RestDataLakeViewer2,
@@ -172,7 +173,7 @@ import {
   SimpleChainContractViewer,
   SimpleFinalizationRunner,
   SimpleFinalizationViewer,
-  SimpleMempoolRunner as SimpleMempoolRunner2,
+  SimpleMempoolRunner,
   SimpleMempoolViewer,
   SimpleStakeEventsViewer,
   SimpleStakeTotalsViewer,
@@ -201,1271 +202,1181 @@ import {
   JsonRpcXyoViewer
 } from "@xyo-network/xl1-rpc";
 
-// src/NodeXyoRunner.ts
-import { assertEx } from "@xylabs/sdk";
-import { asArchivistInstance } from "@xyo-network/sdk-js";
-import { XyoRunnerMoniker as XyoRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
+// src/SimpleDeadLetterQueueRunner.ts
+import { assertEx } from "@ariestools/sdk";
+import { isHashMeta, PayloadBuilder } from "@xyo-network/sdk-js";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider3,
-  creatableProvider as creatableProvider3,
-  SimpleMempoolRunner
-} from "@xyo-network/xl1-protocol-sdk";
-var NodeXyoRunner = class extends AbstractCreatableProvider3 {
-  moniker = XyoRunnerMoniker2;
-  _mempoolRunner;
-  _pendingBlocksArchivist;
-  _pendingTransactionsArchivist;
-  get mempool() {
-    return this._mempoolRunner;
-  }
-  get node() {
-    return this.params.node;
+  DeadLetterQueueRunnerMoniker,
+  isBlockRejection,
+  isTransactionRejection
+} from "@xyo-network/xl1-protocol-lib";
+import { AbstractCreatableProvider as AbstractCreatableProvider3, creatableProvider as creatableProvider3 } from "@xyo-network/xl1-protocol-sdk";
+var SimpleDeadLetterQueueRunner = class extends AbstractCreatableProvider3 {
+  moniker = SimpleDeadLetterQueueRunner.defaultMoniker;
+  get rejectedBlocksArchivist() {
+    return this.params.rejectedBlocksArchivist;
   }
-  get pendingBlocksArchivist() {
-    return this._pendingBlocksArchivist;
+  get rejectedTransactionsArchivist() {
+    return this.params.rejectedTransactionsArchivist;
   }
-  get pendingBlocksArchivistPath() {
-    return this.params.pendingBlocksArchivistPath ?? "XYOChain:Pending:Blocks";
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      rejectedBlocksArchivist: assertEx(params?.rejectedBlocksArchivist, () => "rejectedBlocksArchivist is required"),
+      rejectedTransactionsArchivist: assertEx(params?.rejectedTransactionsArchivist, () => "rejectedTransactionsArchivist is required")
+    };
   }
-  get pendingTransactionsArchivist() {
-    return this._pendingTransactionsArchivist;
+  async pruneRejectedBlocks({
+    batchSize = 10,
+    maxPrune = 1e3,
+    maxCheck = 1e3
+  } = {}) {
+    let total = 0;
+    let pruned = 0;
+    let cursor;
+    let batch = await this.rejectedBlocksArchivist.next({
+      limit: batchSize,
+      cursor,
+      order: "desc"
+    });
+    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
+      const pruneHashes = batch.filter(isHashMeta).filter((p) => !isBlockRejection(p)).map((p) => p._hash);
+      pruned += pruneHashes.length;
+      total += batch.length;
+      if (pruneHashes.length > 0) {
+        await this.rejectedBlocksArchivist.delete(pruneHashes);
+      }
+      const pruneSet = new Set(pruneHashes);
+      const lastSurvivor = batch.findLast((p) => isHashMeta(p) && !pruneSet.has(p._hash));
+      cursor = lastSurvivor?._sequence ?? cursor;
+      batch = await this.rejectedBlocksArchivist.next({
+        limit: batchSize,
+        cursor,
+        order: "desc"
+      });
+    }
+    return [pruned, total];
   }
-  get pendingTransactionsArchivistPath() {
-    return this.params.pendingTransactionsArchivistPath ?? "XYOChain:Pending:Transactions";
+  async pruneRejectedTransactions({
+    batchSize = 10,
+    maxPrune = 1e3,
+    maxCheck = 1e3
+  } = {}) {
+    let total = 0;
+    let pruned = 0;
+    let cursor;
+    let batch = await this.rejectedTransactionsArchivist.next({
+      limit: batchSize,
+      cursor,
+      order: "desc"
+    });
+    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
+      const pruneHashes = batch.filter(isHashMeta).filter((p) => !isTransactionRejection(p)).map((p) => p._hash);
+      pruned += pruneHashes.length;
+      total += batch.length;
+      if (pruneHashes.length > 0) {
+        await this.rejectedTransactionsArchivist.delete(pruneHashes);
+      }
+      const pruneSet = new Set(pruneHashes);
+      const lastSurvivor = batch.findLast((p) => isHashMeta(p) && !pruneSet.has(p._hash));
+      cursor = lastSurvivor?._sequence ?? cursor;
+      batch = await this.rejectedTransactionsArchivist.next({
+        limit: batchSize,
+        cursor,
+        order: "desc"
+      });
+    }
+    return [pruned, total];
   }
-  async broadcastTransaction(transaction) {
-    const [txHash] = await this.mempool.submitTransactions([transaction]);
-    return txHash;
+  async rejectBlock(rejection) {
+    const withMeta = await PayloadBuilder.addHashMeta(rejection);
+    const inserted = await this.rejectedBlocksArchivist.insert([withMeta]);
+    return inserted.length > 0;
   }
-  getArchivist = async (identifier) => {
-    const archivist = await this.node.resolve(identifier);
-    return assertEx(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
-  };
-  async startHandler() {
-    await super.startHandler();
-    this._pendingTransactionsArchivist = assertEx(
-      await this.getArchivist(this.pendingTransactionsArchivistPath),
-      () => `Could not resolve pending archivist at ${this.pendingTransactionsArchivistPath}`
-    );
-    this._pendingBlocksArchivist = assertEx(
-      await this.getArchivist(this.pendingBlocksArchivistPath),
-      () => `Could not resolve pending archivist at ${this.pendingBlocksArchivistPath}`
-    );
-    this._mempoolRunner = assertEx(await SimpleMempoolRunner.create({
-      context: this.context,
-      pendingTransactionsArchivist: this.pendingTransactionsArchivist,
-      pendingBlocksArchivist: this.pendingBlocksArchivist
-    }), () => "Failed to create SimpleMempoolRunner");
+  async rejectTransaction(rejection) {
+    const withMeta = await PayloadBuilder.addHashMeta(rejection);
+    const inserted = await this.rejectedTransactionsArchivist.insert([withMeta]);
+    return inserted.length > 0;
   }
 };
-__publicField(NodeXyoRunner, "connectionTypes", ["lmdb", "mongo", "memory"]);
-__publicField(NodeXyoRunner, "defaultMoniker", XyoRunnerMoniker2);
-__publicField(NodeXyoRunner, "dependencies", []);
-__publicField(NodeXyoRunner, "monikers", [XyoRunnerMoniker2]);
-__publicField(NodeXyoRunner, "surface", "node");
-NodeXyoRunner = __decorateClass([
+__publicField(SimpleDeadLetterQueueRunner, "connectionTypes", ["lmdb", "mongo", "memory"]);
+__publicField(SimpleDeadLetterQueueRunner, "defaultMoniker", DeadLetterQueueRunnerMoniker);
+__publicField(SimpleDeadLetterQueueRunner, "dependencies", []);
+__publicField(SimpleDeadLetterQueueRunner, "monikers", [DeadLetterQueueRunnerMoniker]);
+__publicField(SimpleDeadLetterQueueRunner, "surface", "node");
+SimpleDeadLetterQueueRunner = __decorateClass([
   creatableProvider3()
-], NodeXyoRunner);
-
-// src/NodeXyoViewer.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk";
-import { asAttachableArchivistInstance } from "@xyo-network/sdk-js";
-import { creatableProvider as creatableProvider5 } from "@xyo-network/xl1-protocol-sdk";
+], SimpleDeadLetterQueueRunner);
 
-// src/SimpleXyoViewer.ts
+// src/SimpleDeadLetterQueueViewer.ts
 import {
-  assertEx as assertEx2,
-  toAddress
-} from "@xylabs/sdk";
+  exists,
+  isDefined,
+  isHash
+} from "@ariestools/sdk";
+import { isHashMeta as isHashMeta2 } from "@xyo-network/sdk-js";
+import {
+  DeadLetterQueueViewerMoniker,
+  isBlockRejection as isBlockRejection2,
+  isTransactionRejection as isTransactionRejection2
+} from "@xyo-network/xl1-protocol-lib";
+import { AbstractCreatableProvider as AbstractCreatableProvider4, creatableProvider as creatableProvider4 } from "@xyo-network/xl1-protocol-sdk";
+var SimpleDeadLetterQueueViewer = class extends AbstractCreatableProvider4 {
+  moniker = SimpleDeadLetterQueueViewer.defaultMoniker;
+  get rejectedBlocksArchivist() {
+    return this.params.rejectedBlocksArchivist;
+  }
+  get rejectedTransactionsArchivist() {
+    return this.params.rejectedTransactionsArchivist;
+  }
+  async rejectedBlocks({
+    cursor: providedCursor,
+    limit = 100,
+    rejector
+  } = {}) {
+    let cursor;
+    if (isHash(providedCursor)) {
+      const [p] = await this.rejectedBlocksArchivist.get([providedCursor]);
+      if (isDefined(p)) {
+        cursor = p._sequence;
+      }
+    }
+    const payloads = await this.rejectedBlocksArchivist.next({
+      order: "desc",
+      limit,
+      cursor
+    });
+    const rejections = payloads.filter(isHashMeta2).map((p) => isBlockRejection2(p) ? p : void 0).filter(exists);
+    if (rejector !== void 0) {
+      return rejections.filter((r) => r.rejector === rejector);
+    }
+    return rejections;
+  }
+  async rejectedTransactions({
+    cursor: providedCursor,
+    limit = 100,
+    rejector
+  } = {}) {
+    let cursor;
+    if (isHash(providedCursor)) {
+      const [p] = await this.rejectedTransactionsArchivist.get([providedCursor]);
+      if (isDefined(p)) {
+        cursor = p._sequence;
+      }
+    }
+    const payloads = await this.rejectedTransactionsArchivist.next({
+      order: "desc",
+      limit,
+      cursor
+    });
+    const rejections = payloads.filter(isHashMeta2).map((p) => isTransactionRejection2(p) ? p : void 0).filter(exists);
+    if (rejector !== void 0) {
+      return rejections.filter((r) => r.rejector === rejector);
+    }
+    return rejections;
+  }
+};
+__publicField(SimpleDeadLetterQueueViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
+__publicField(SimpleDeadLetterQueueViewer, "defaultMoniker", DeadLetterQueueViewerMoniker);
+__publicField(SimpleDeadLetterQueueViewer, "dependencies", []);
+__publicField(SimpleDeadLetterQueueViewer, "monikers", [DeadLetterQueueViewerMoniker]);
+__publicField(SimpleDeadLetterQueueViewer, "surface", "node");
+SimpleDeadLetterQueueViewer = __decorateClass([
+  creatableProvider4()
+], SimpleDeadLetterQueueViewer);
+
+// src/SimpleNetworkStakeViewer.ts
+import { assertEx as assertEx2 } from "@ariestools/sdk";
 import {
-  AccountBalanceViewerMoniker,
-  asAttoXL1,
-  asXL1BlockRange,
-  BlockViewerMoniker,
-  ChainContractViewerMoniker,
   FinalizationViewerMoniker,
-  MempoolViewerMoniker,
-  NetworkStakeStepRewardsByPositionViewerMoniker,
+  NetworkStakeStepRewardsViewerMoniker,
   NetworkStakeViewerMoniker,
-  StakeViewerMoniker,
-  StepViewerMoniker,
-  TimeSyncViewerMoniker,
-  TransactionViewerMoniker,
-  XYO_NETWORK_STAKING_ADDRESS,
-  XYO_ZERO_ADDRESS,
-  XyoViewerMoniker as XyoViewerMoniker3
+  StakeTotalsViewerMoniker,
+  StakeViewerMoniker
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider4,
-  allStakersForStep,
-  blockRangeSteps,
-  creatableProvider as creatableProvider4,
-  externalBlockRangeFromStep,
-  externalBlockRangeFromXL1BlockRange,
-  networkStakeStepRewardPositionWeight,
-  stepRewardTotal,
-  toStepIdentityString,
-  weightedStakeForRangeByPosition,
-  withContextCacheResponse
+  AbstractCreatableProvider as AbstractCreatableProvider5,
+  creatableProvider as creatableProvider5
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleXyoViewer = class extends AbstractCreatableProvider4 {
-  moniker = SimpleXyoViewer.defaultMoniker;
-  _tracer;
-  _accountBalanceViewer;
-  _blockViewer;
-  _chainContractViewer;
-  _chainId;
+var SimpleNetworkStakeViewer = class extends AbstractCreatableProvider5 {
+  moniker = SimpleNetworkStakeViewer.defaultMoniker;
   _finalizationViewer;
-  _mempoolViewer;
-  _networkStakeViewer;
-  _networkStepRewardsByPositionViewer;
-  _rewardMultipliers;
-  _stakeViewer;
-  _stepViewer;
-  _timeSyncViewer;
-  _transaction;
-  get account() {
-    return { balance: this._accountBalanceViewer };
-  }
-  get block() {
-    return this._blockViewer;
-  }
-  get chainContractViewer() {
-    return this._chainContractViewer;
+  _stake;
+  _stakeTotals;
+  _stepRewardsViewer;
+  get stepRewards() {
+    return assertEx2(this._stepRewardsViewer, () => "Step rewards viewer not initialized");
   }
-  get finalization() {
+  get finalizationViewer() {
     return this._finalizationViewer;
   }
-  get mempool() {
-    return this._mempoolViewer;
-  }
-  get networkStake() {
-    return this._networkStakeViewer;
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers;
   }
   get stake() {
-    return this._stakeViewer;
-  }
-  get step() {
-    return this._stepViewer;
-  }
-  get time() {
-    return this._timeSyncViewer;
+    return this._stake;
   }
-  get transaction() {
-    return this._transaction;
+  get stakeTotals() {
+    return this._stakeTotals;
   }
-  get finalizationViewer() {
-    return this._finalizationViewer;
+  async active(blockNumber) {
+    const resolvedBlockNumber = blockNumber ?? await this.finalizationViewer.headNumber();
+    return [await this.stakeTotals.active(resolvedBlockNumber), resolvedBlockNumber];
   }
-  get initRewardsCache() {
-    return this.params.initRewardsCache ?? true;
-  }
-  get networkStepRewardsByPositionViewer() {
-    return this._networkStepRewardsByPositionViewer;
+  async createHandler() {
+    await super.createHandler();
+    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker);
+    this._stake = await this.locator.getInstance(StakeViewerMoniker);
+    this._stakeTotals = await this.locator.getInstance(StakeTotalsViewerMoniker);
+    this._stepRewardsViewer = await this.locator.getInstance(NetworkStakeStepRewardsViewerMoniker);
   }
+};
+__publicField(SimpleNetworkStakeViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
+__publicField(SimpleNetworkStakeViewer, "defaultMoniker", NetworkStakeViewerMoniker);
+__publicField(SimpleNetworkStakeViewer, "dependencies", [
+  FinalizationViewerMoniker,
+  NetworkStakeStepRewardsViewerMoniker,
+  StakeTotalsViewerMoniker,
+  StakeViewerMoniker
+]);
+__publicField(SimpleNetworkStakeViewer, "monikers", [NetworkStakeViewerMoniker]);
+__publicField(SimpleNetworkStakeViewer, "surface", "node");
+SimpleNetworkStakeViewer = __decorateClass([
+  creatableProvider5()
+], SimpleNetworkStakeViewer);
+
+// src/SimpleStepRewards/SimpleStepRewardsByPositionViewer.ts
+import { isArray } from "@ariestools/sdk";
+import {
+  asAttoXL1,
+  asXL1BlockRange,
+  BlockViewerMoniker,
+  FinalizationViewerMoniker as FinalizationViewerMoniker2,
+  NetworkStakeStepRewardsByPositionViewerMoniker,
+  StakeViewerMoniker as StakeViewerMoniker2
+} from "@xyo-network/xl1-protocol-lib";
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider6,
+  blockRangeSteps,
+  creatableProvider as creatableProvider6
+} from "@xyo-network/xl1-protocol-sdk";
+
+// src/SimpleStepRewards/primitives/networkStakeStepRewardEarned.ts
+import { XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS2 } from "@xyo-network/xl1-protocol-lib";
+import { withContextCacheResponse as withContextCacheResponse2 } from "@xyo-network/xl1-protocol-sdk";
+
+// src/SimpleStepRewards/primitives/networkStakeStepRewardEarnedForPosition.ts
+import { XYO_NETWORK_STAKING_ADDRESS } from "@xyo-network/xl1-protocol-lib";
+import {
+  externalBlockRangeFromStep,
+  stepRewardTotal,
+  weightedStakeForRangeByPosition,
+  withContextCacheResponse
+} from "@xyo-network/xl1-protocol-sdk";
+async function networkStakeStepRewardEarnedForPosition(context, blockViewer, stakeEventsViewer, stepIdentity, position, rewardMultipliers = {}) {
+  const cacheKey = `${stepIdentity.block}|${stepIdentity.step}|${position.id}`;
+  return await withContextCacheResponse(context, "networkStakeStepRewardEarnedForPosition", cacheKey, async () => {
+    const range = await externalBlockRangeFromStep(context, blockViewer, stepIdentity);
+    const numerator = position.staked === XYO_NETWORK_STAKING_ADDRESS ? await weightedStakeForRangeByPosition(
+      context,
+      blockViewer,
+      stakeEventsViewer,
+      range,
+      XYO_NETWORK_STAKING_ADDRESS,
+      position.id
+    ) : 0n;
+    const denominator = await weightedStakeForRangeByPosition(
+      context,
+      blockViewer,
+      stakeEventsViewer,
+      range
+    );
+    const totalReward = await stepRewardTotal(context, blockViewer, stepIdentity, rewardMultipliers);
+    const positionReward = denominator > 0n ? totalReward * numerator / denominator : 0n;
+    const result = [positionReward, totalReward];
+    return result;
+  });
+}
+
+// src/SimpleStepRewards/primitives/networkStakeStepRewardEarned.ts
+async function networkStakeStepRewardEarned(context, blockViewer, stakeViewer, stepIdentity, rewardMultipliers = {}) {
+  const cacheKey = `${stepIdentity.block}|${stepIdentity.step}`;
+  return await withContextCacheResponse2(context, "networkStakeStepRewardEarned", cacheKey, async () => {
+    const positions = await stakeViewer.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS2);
+    const results = await Promise.all(positions.map((pos) => {
+      return networkStakeStepRewardEarnedForPosition(
+        context,
+        blockViewer,
+        stakeViewer.stakeEvents,
+        stepIdentity,
+        pos,
+        rewardMultipliers
+      );
+    }));
+    const numerator = results.reduce((acc, [positionReward]) => acc + positionReward, 0n);
+    const result = results.length > 0 ? [numerator, results[0][1]] : [0n, 0n];
+    return result;
+  });
+}
+
+// src/SimpleStepRewards/primitives/networkStakeStepRewardEarnedForStaker.ts
+import { XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS3 } from "@xyo-network/xl1-protocol-lib";
+import {
+  toStepIdentityString,
+  withContextCacheResponse as withContextCacheResponse3
+} from "@xyo-network/xl1-protocol-sdk";
+async function networkStakeStepRewardEarnedForStaker(context, blockViewer, stakeViewer, stepIdentity, staker, rewardMultipliers = {}) {
+  const stepId = toStepIdentityString(stepIdentity);
+  return await withContextCacheResponse3(context, "networkStakeStepRewardEarnedForStaker", `${stepId}-${staker}`, async () => {
+    const stakes = await stakeViewer.stakesByStaker(staker);
+    const positions = stakes.filter((pos) => pos.staked === XYO_NETWORK_STAKING_ADDRESS3);
+    const results = await Promise.all(positions.map((pos) => {
+      return networkStakeStepRewardEarnedForPosition(
+        context,
+        blockViewer,
+        stakeViewer.stakeEvents,
+        stepIdentity,
+        pos,
+        rewardMultipliers
+      );
+    }));
+    const numerator = results.reduce((acc, [positionReward]) => acc + positionReward, 0n);
+    const result = results.length > 0 ? [numerator, results[0][1]] : [0n, 0n];
+    return result;
+  });
+}
+
+// src/SimpleStepRewards/SimpleStepRewardsByPositionViewer.ts
+var SimpleStepRewardsByPositionViewer = class extends AbstractCreatableProvider6 {
+  moniker = SimpleStepRewardsByPositionViewer.defaultMoniker;
+  _blockViewer;
+  _finalizationViewer;
+  _stakeViewer;
   get rewardMultipliers() {
-    this._rewardMultipliers = this._rewardMultipliers ?? this.params.rewardMultipliers ?? {};
-    return this._rewardMultipliers;
-  }
-  async accountBalance(address, config = {}) {
-    return await this.account.balance.accountBalance(address, config);
-  }
-  async accountBalanceHistory(address, config = {}) {
-    return await this.account.balance.accountBalanceHistory(address, config);
-  }
-  async blockByHash(hash) {
-    return await this.block.blockByHash(hash);
+    return this.params.rewardMultipliers ?? {};
   }
-  async blockByNumber(blockNumber) {
-    return await this.block.blockByNumber(blockNumber);
+  get blockViewer() {
+    return this._blockViewer;
   }
-  async blocksByHash(hash, limit = 10) {
-    return await this.block.blocksByHash(hash, limit);
+  get finalizationViewer() {
+    return this._finalizationViewer;
   }
-  async blocksByNumber(blockNumber, limit = 10) {
-    return await this.block.blocksByNumber(blockNumber, limit);
+  get stakeViewer() {
+    return this._stakeViewer;
   }
-  async blocksByStep(stepLevel, stepIndex) {
-    return await this.block.blocksByStep(stepLevel, stepIndex);
+  async bonus({ range, positions } = {}) {
+    const total = await this.total({ range, positions });
+    const earned = await this.earned({ range, positions });
+    const result = {};
+    for (const key of Object.keys(total)) {
+      const pos = Number(key);
+      result[pos] = asAttoXL1(total[pos] - (earned[pos] ?? 0n));
+    }
+    return result;
   }
-  async chainId(blockNumber = "latest") {
-    return await this.spanAsync("SimpleXyoViewer:chainId", async () => {
-      const chainId = assertEx2(
-        blockNumber === "latest" ? this._chainId : await this.chainContractViewer.chainIdAtBlockNumber(blockNumber),
-        () => `Could not find block for chainId at block ${blockNumber}`
-      );
-      return chainId;
-    }, this.context);
+  claimed(_options) {
+    throw new Error("Method [claimed] not implemented.");
   }
   async createHandler() {
     await super.createHandler();
-    this._accountBalanceViewer = await this.locator.getInstance(AccountBalanceViewerMoniker);
     this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
-    this._chainContractViewer = await this.locator.getInstance(ChainContractViewerMoniker);
-    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker);
-    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker);
-    this._networkStakeViewer = await this.locator.getInstance(NetworkStakeViewerMoniker);
-    this._networkStepRewardsByPositionViewer = await this.locator.getInstance(NetworkStakeStepRewardsByPositionViewerMoniker);
-    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker);
-    this._stepViewer = await this.locator.getInstance(StepViewerMoniker);
-    this._timeSyncViewer = await this.locator.getInstance(TimeSyncViewerMoniker);
-    this._transaction = await this.locator.getInstance(TransactionViewerMoniker);
-    this._chainId = await this._chainContractViewer.chainId();
-  }
-  async currentBlock() {
-    return await this.block.currentBlock();
-  }
-  async currentBlockHash() {
-    return await this.block.currentBlockHash();
-  }
-  async currentBlockNumber() {
-    return await this.block.currentBlockNumber();
-  }
-  forkHistory() {
-    throw new Error("Method [forkHistory] not implemented.");
-  }
-  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.");
+    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker2);
+    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker2);
   }
-  async networkStakeStepRewardForPosition(position, range) {
-    const cacheKey = `${position}|${range[0]}-${range[1]}`;
-    return await withContextCacheResponse(this.context, "SimpleXyoViewer:networkStakeStepRewardForPosition", cacheKey, async () => {
-      const externalRange = await externalBlockRangeFromXL1BlockRange(this.context, this.block, range);
-      const positionCount = await this.stake.stakeEvents.positionCount(externalRange);
-      if (positionCount === 0) {
-        return [asAttoXL1(0n), asAttoXL1(0n)];
-      }
-      const steps = blockRangeSteps(range, [3, 4, 5, 6, 7]);
-      const rewards = await Promise.all(steps.map((step) => this.networkStakeStepRewardForStepForPosition(step, position)));
-      const positionReward = asAttoXL1(rewards.reduce((a, b) => a + b[0], 0n));
-      const totalReward = asAttoXL1(rewards.reduce((a, b) => a + b[1], 0n));
-      return [positionReward, totalReward];
-    });
+  async earned({ range, positions } = {}) {
+    return await this.calculateRewards({ range, positions });
   }
-  async networkStakeStepRewardForStep(stepContext) {
-    return await stepRewardTotal(this.context, this.block, stepContext, this.rewardMultipliers);
+  async total({ range, positions } = {}) {
+    return await this.calculateRewards({ range, positions }, this.rewardMultipliers);
   }
-  async networkStakeStepRewardForStepForPosition(stepIdentity, position) {
-    const stepIdentityString = toStepIdentityString(stepIdentity);
-    const cacheKey = `${stepIdentityString}|${position}`;
-    return await withContextCacheResponse(this.context, "SimpleXyoViewer:networkStakeStepRewardForStepForPosition", cacheKey, async () => {
-      const range = await externalBlockRangeFromStep(this.context, this.block, stepIdentity);
-      const stake = await this.stakeById(position);
-      const numerator = stake.staked === XYO_NETWORK_STAKING_ADDRESS ? await weightedStakeForRangeByPosition(this.context, this.block, this.stake.stakeEvents, range, XYO_NETWORK_STAKING_ADDRESS, position) : 0n;
-      const denominator = await this.stepWeightedDenominator(stepIdentity);
-      const totalReward = await this.networkStakeStepRewardForStep(stepIdentity);
-      const positionReward = asAttoXL1(denominator > 0n ? totalReward * numerator / denominator : 0n);
-      const result = [positionReward, totalReward];
-      return result;
-    });
+  unclaimed(_options = {}) {
+    throw new Error("Method [unclaimed] not implemented.");
   }
-  async networkStakeStepRewardPoolRewards(step) {
-    const stakes = await this.stake.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS);
-    const rewards = [];
-    for (const stake of stakes) {
-      rewards.push([stake.staker, await this.networkStakeStepRewardForStepForPosition(
-        step,
-        stake.id
-      )]);
-    }
+  async calculateRewards({ range, positions } = {}, rewardMultipliers) {
     const result = {};
-    for (const [staker, reward] of rewards) {
-      result[staker] = asAttoXL1((result[staker] ?? 0n) + reward[0]);
-    }
-    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v > 0n));
-    return filtered;
-  }
-  networkStakeStepRewardPoolShares(_context) {
-    throw new Error("Method [networkStakeStepRewardPoolShares] not implemented.");
-  }
-  async networkStakeStepRewardPositionWeight(stepContext, position) {
-    return await networkStakeStepRewardPositionWeight(this.context, this.block, this.stake.stakeEvents, stepContext, position);
-  }
-  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
-    throw new Error("Method [networkStakeStepRewardPotentialPositionLoss] not implemented.");
-  }
-  networkStakeStepRewardRandomizer(_context) {
-    throw new Error("Method [networkStakeStepRewardRandomizer] not implemented.");
-  }
-  async networkStakeStepRewardStakerCount(stepContext) {
-    return Object.keys(await allStakersForStep(
-      this.context,
-      this.block,
-      this.stake.stakeEvents,
-      stepContext,
-      XYO_NETWORK_STAKING_ADDRESS
-    )).length;
-  }
-  networkStakeStepRewardUnclaimedByAddress(_address) {
-    throw new Error("Method [networkStakeStepRewardUnclaimedByAddress] not implemented.");
-  }
-  networkStakeStepRewardWeightForAddress(_context, _address) {
-    throw new Error("Method [networkStakeStepRewardWeightForAddress] not implemented.");
-  }
-  async networkStakeStepRewardsForPosition(position, range) {
-    const steps = blockRangeSteps(range, [3, 4, 5, 6, 7, 8]);
-    const rewards = await Promise.all(steps.map(async (step) => {
-      return [toStepIdentityString(step), await this.networkStakeStepRewardForStepForPosition(step, position)];
-    }));
-    const result = Object.fromEntries(rewards);
-    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v[0] > 0n));
-    return filtered;
-  }
-  async networkStakeStepRewardsForRange(range) {
-    return await this.spanAsync("networkStakeStepRewardsForRange", async () => {
-      const steps = blockRangeSteps(range, [3, 4, 5, 6, 7, 8]);
-      const rewards = await Promise.all(steps.map(async (step) => {
-        return await this.networkStakeStepRewardForStep(step);
-      }));
-      return asAttoXL1(rewards.reduce((a, b) => a + b, 0n));
-    }, this.context);
-  }
-  async networkStakeStepRewardsForStepLevel(stepLevel, range) {
-    const steps = blockRangeSteps(range, [stepLevel]);
-    const rewards = await Promise.all(steps.map(async (step) => {
-      return await this.networkStakeStepRewardForStep(step);
-    }));
-    return asAttoXL1(rewards.reduce((a, b) => a + b, 0n));
-  }
-  payloadByHash(_hash) {
-    throw new Error("Method [payloadByHash] not implemented.");
-  }
-  payloadsByHash(_hashes) {
-    throw new Error("Method [payloadsByHash] not implemented.");
-  }
-  async rate(range, timeUnit) {
-    return await this.block.rate(range, timeUnit);
-  }
-  async stakeById(id) {
-    return await this.stake.stakeById(id);
-  }
-  async stakeByStaker(staker, slot) {
-    return await this.stake.stakeByStaker(staker, slot);
-  }
-  async stakedByStaker(staker) {
-    const result = /* @__PURE__ */ new Set();
-    let slot = 0;
-    while (true) {
-      try {
-        const ethStake = await this.stake.stakeByStaker(staker, slot);
-        result.add(toAddress(ethStake.staked));
-        slot++;
-      } catch {
-        break;
-      }
-    }
-    return [...result];
-  }
-  async stakesByStaked(staked) {
-    return await this.stake.stakesByStaked(staked);
-  }
-  async stakesByStaker(staker) {
-    return await this.stake.stakesByStaker(staker);
-  }
-  async stepSizeRate(start, stepSizeIndex, count, timeUnit) {
-    return await this.block.stepSizeRate(start, stepSizeIndex, count, timeUnit);
-  }
-  async timeDurationRate(timeConfig, startBlock, timeUnit, toleranceMs, maxAttempts) {
-    return await this.block.timeDurationRate(timeConfig, startBlock, timeUnit, toleranceMs, maxAttempts);
-  }
-  async transactionByBlockHashAndIndex(blockHash, transactionIndex = 0) {
-    return await this.transaction.byBlockHashAndIndex(blockHash, transactionIndex);
-  }
-  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex = 0) {
-    return await this.transaction.byBlockNumberAndIndex(blockNumber, transactionIndex);
-  }
-  async transactionByHash(transactionHash) {
-    return await this.transaction.byHash(transactionHash);
-  }
-  async startHandler() {
-    try {
-      const currentBlockNumber = await this.currentBlockNumber();
-      await this.account.balance.accountBalance(XYO_ZERO_ADDRESS);
-      if (this.initRewardsCache) {
-        const externalRange = await externalBlockRangeFromXL1BlockRange(
-          this.context,
-          this.block,
-          asXL1BlockRange([0, currentBlockNumber], { name: "startHandler" })
-        );
-        const positionCount = await this.stake.stakeEvents.positionCount(externalRange);
-        this.logger?.debug(`SimpleXyoViewer: Precomputing networkStakeStepRewardForPosition up to position ${positionCount - 1}`);
-        const positions = Array.from(
-          { length: positionCount },
-          (_, i) => i
-        );
-        while (positions.length > 0) {
-          const batch = positions.splice(0, 10);
-          this.logger?.debug(`SimpleXyoViewer: Precomputing networkStakeStepRewardForPosition for positions ${batch.at(0)} - ${batch.at(-1)}`);
-          await Promise.all(batch.map(async (_, position) => await this.networkStakeStepRewardForPosition(
+    const head = await this.finalizationViewer.head();
+    const steps = blockRangeSteps(asXL1BlockRange(
+      range ?? [0, head[1]],
+      { name: "NodeStepRewardsByPositionViewer" }
+    ), [3, 4, 5, 6, 7]);
+    for (const step of steps) {
+      if (isArray(positions)) {
+        for (const positionId of positions) {
+          const position = await this.stakeViewer.stakeById(positionId);
+          const reward = await networkStakeStepRewardEarnedForPosition(
+            this.context,
+            this.blockViewer,
+            this.stakeViewer.stakeEvents,
+            step,
             position,
-            asXL1BlockRange([0, currentBlockNumber], { name: "startHandler" })
-          )));
+            rewardMultipliers
+          );
+          result[positionId] = asAttoXL1((result[positionId] ?? 0n) + reward[0]);
         }
-        this.logger?.debug(`SimpleXyoViewer: Precomputed networkStakeStepRewardForPosition up to position ${positionCount - 1}`);
       }
-    } catch (ex) {
-      this.logger?.error(`SimpleXyoViewer: Error during startHandler initialization: ${ex.message}`);
-      this.logger?.error(ex.stack ?? "<No Stack>");
-      throw ex;
     }
-  }
-  async stepWeightedDenominator(stepIdentity, staked) {
-    const cacheKey = toStepIdentityString(stepIdentity);
-    return await withContextCacheResponse(this.context, "NodeXyoViewer-networkStakeStepRewardForStepForPosition-denominator", cacheKey, async () => {
-      const range = await externalBlockRangeFromStep(this.context, this.block, stepIdentity);
-      return await weightedStakeForRangeByPosition(this.context, this.block, this.stake.stakeEvents, range, staked);
-    });
-  }
-};
-__publicField(SimpleXyoViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
-__publicField(SimpleXyoViewer, "defaultMoniker", XyoViewerMoniker3);
-__publicField(SimpleXyoViewer, "dependencies", [
-  AccountBalanceViewerMoniker,
-  BlockViewerMoniker,
-  ChainContractViewerMoniker,
-  FinalizationViewerMoniker,
-  MempoolViewerMoniker,
-  NetworkStakeViewerMoniker,
-  NetworkStakeStepRewardsByPositionViewerMoniker,
-  StakeViewerMoniker,
-  StepViewerMoniker,
-  TimeSyncViewerMoniker,
-  TransactionViewerMoniker
-]);
-__publicField(SimpleXyoViewer, "monikers", [XyoViewerMoniker3]);
-__publicField(SimpleXyoViewer, "surface", "node");
-SimpleXyoViewer = __decorateClass([
-  creatableProvider4()
-], SimpleXyoViewer);
-
-// src/NodeXyoViewer.ts
-var NodeXyoViewer = class extends SimpleXyoViewer {
-  get node() {
-    return this.params.node;
-  }
-  static async getFinalizedArchivistFromNode(node) {
-    const resolved = await this.getArchivist(node, this.finalizedArchivistPath);
-    return assertEx3(resolved, () => `Could not resolve finalized archivist at ${this.finalizedArchivistPath}`);
+    return result;
   }
 };
-__publicField(NodeXyoViewer, "finalizedArchivistPath", "XYOChain:Chain:Finalized");
-__publicField(NodeXyoViewer, "getArchivist", async (node, identifier) => {
-  const archivist = await node.resolve(identifier);
-  return assertEx3(asAttachableArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
-});
-NodeXyoViewer = __decorateClass([
-  creatableProvider5()
-], NodeXyoViewer);
+__publicField(SimpleStepRewardsByPositionViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
+__publicField(SimpleStepRewardsByPositionViewer, "defaultMoniker", NetworkStakeStepRewardsByPositionViewerMoniker);
+__publicField(SimpleStepRewardsByPositionViewer, "dependencies", [BlockViewerMoniker, FinalizationViewerMoniker2, StakeViewerMoniker2]);
+__publicField(SimpleStepRewardsByPositionViewer, "monikers", [NetworkStakeStepRewardsByPositionViewerMoniker]);
+__publicField(SimpleStepRewardsByPositionViewer, "surface", "node");
+SimpleStepRewardsByPositionViewer = __decorateClass([
+  creatableProvider6()
+], SimpleStepRewardsByPositionViewer);
 
-// src/SimpleDeadLetterQueueRunner.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk";
-import { isHashMeta, PayloadBuilder } from "@xyo-network/sdk-js";
+// src/SimpleStepRewards/SimpleStepRewardsByStakerViewer.ts
+import { isArray as isArray2 } from "@ariestools/sdk";
 import {
-  DeadLetterQueueRunnerMoniker,
-  isBlockRejection,
-  isTransactionRejection
+  asAttoXL1 as asAttoXL12,
+  asXL1BlockRange as asXL1BlockRange2,
+  BlockViewerMoniker as BlockViewerMoniker2,
+  FinalizationViewerMoniker as FinalizationViewerMoniker3,
+  NetworkStakeStepRewardsByStakerViewerMoniker,
+  StakeViewerMoniker as StakeViewerMoniker3
 } from "@xyo-network/xl1-protocol-lib";
-import { AbstractCreatableProvider as AbstractCreatableProvider5, creatableProvider as creatableProvider6 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleDeadLetterQueueRunner = class extends AbstractCreatableProvider5 {
-  moniker = SimpleDeadLetterQueueRunner.defaultMoniker;
-  get rejectedBlocksArchivist() {
-    return this.params.rejectedBlocksArchivist;
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider7,
+  blockRangeSteps as blockRangeSteps2,
+  creatableProvider as creatableProvider7
+} from "@xyo-network/xl1-protocol-sdk";
+var SimpleStepRewardsByStakerViewer = class extends AbstractCreatableProvider7 {
+  moniker = SimpleStepRewardsByStakerViewer.defaultMoniker;
+  _blockViewer;
+  _finalizationViewer;
+  _stakeViewer;
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {};
   }
-  get rejectedTransactionsArchivist() {
-    return this.params.rejectedTransactionsArchivist;
+  get blockViewer() {
+    return this._blockViewer;
   }
-  static async paramsHandler(params) {
-    return {
-      ...await super.paramsHandler(params),
-      rejectedBlocksArchivist: assertEx4(params?.rejectedBlocksArchivist, () => "rejectedBlocksArchivist is required"),
-      rejectedTransactionsArchivist: assertEx4(params?.rejectedTransactionsArchivist, () => "rejectedTransactionsArchivist is required")
-    };
+  get finalizationViewer() {
+    return this._finalizationViewer;
   }
-  async pruneRejectedBlocks({
-    batchSize = 10,
-    maxPrune = 1e3,
-    maxCheck = 1e3
-  } = {}) {
-    let total = 0;
-    let pruned = 0;
-    let cursor;
-    let batch = await this.rejectedBlocksArchivist.next({
-      limit: batchSize,
-      cursor,
-      order: "desc"
-    });
-    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
-      const pruneHashes = batch.filter(isHashMeta).filter((p) => !isBlockRejection(p)).map((p) => p._hash);
-      pruned += pruneHashes.length;
-      total += batch.length;
-      if (pruneHashes.length > 0) {
-        await this.rejectedBlocksArchivist.delete(pruneHashes);
-      }
-      const pruneSet = new Set(pruneHashes);
-      const lastSurvivor = batch.findLast((p) => isHashMeta(p) && !pruneSet.has(p._hash));
-      cursor = lastSurvivor?._sequence ?? cursor;
-      batch = await this.rejectedBlocksArchivist.next({
-        limit: batchSize,
-        cursor,
-        order: "desc"
-      });
+  get stakeViewer() {
+    return this._stakeViewer;
+  }
+  async bonus({ range, stakers } = {}) {
+    const total = await this.total({ range, stakers });
+    const earned = await this.earned({ range, stakers });
+    const result = {};
+    for (const staker of Object.keys(total)) {
+      result[staker] = asAttoXL12(total[staker] - (earned[staker] ?? 0n));
     }
-    return [pruned, total];
+    return result;
   }
-  async pruneRejectedTransactions({
-    batchSize = 10,
-    maxPrune = 1e3,
-    maxCheck = 1e3
-  } = {}) {
-    let total = 0;
-    let pruned = 0;
-    let cursor;
-    let batch = await this.rejectedTransactionsArchivist.next({
-      limit: batchSize,
-      cursor,
-      order: "desc"
-    });
-    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
-      const pruneHashes = batch.filter(isHashMeta).filter((p) => !isTransactionRejection(p)).map((p) => p._hash);
-      pruned += pruneHashes.length;
-      total += batch.length;
-      if (pruneHashes.length > 0) {
-        await this.rejectedTransactionsArchivist.delete(pruneHashes);
+  claimed(_options) {
+    throw new Error("Method [claimed] not implemented.");
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker2);
+    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker3);
+    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker3);
+  }
+  async earned(options = {}) {
+    return await this.calculateRewards(options);
+  }
+  async total(options = {}) {
+    return await this.calculateRewards(options, this.rewardMultipliers);
+  }
+  unclaimed(_options = {}) {
+    throw new Error("Method [unclaimed] not implemented.");
+  }
+  async calculateRewards({ range, stakers } = {}, rewardMultipliers) {
+    const result = {};
+    const steps = blockRangeSteps2(asXL1BlockRange2(
+      range ?? [0, await this.finalizationViewer.headNumber()],
+      { name: "NodeStepRewardsByStakerViewer" }
+    ), [3, 4, 5, 6, 7]);
+    for (const step of steps) {
+      if (isArray2(stakers)) {
+        for (const staker of stakers) {
+          const reward = await networkStakeStepRewardEarnedForStaker(
+            this.context,
+            this.blockViewer,
+            this.stakeViewer,
+            step,
+            staker,
+            rewardMultipliers
+          );
+          result[staker] = asAttoXL12((result[staker] ?? 0n) + reward[0]);
+        }
       }
-      const pruneSet = new Set(pruneHashes);
-      const lastSurvivor = batch.findLast((p) => isHashMeta(p) && !pruneSet.has(p._hash));
-      cursor = lastSurvivor?._sequence ?? cursor;
-      batch = await this.rejectedTransactionsArchivist.next({
-        limit: batchSize,
-        cursor,
-        order: "desc"
-      });
     }
-    return [pruned, total];
-  }
-  async rejectBlock(rejection) {
-    const withMeta = await PayloadBuilder.addHashMeta(rejection);
-    const inserted = await this.rejectedBlocksArchivist.insert([withMeta]);
-    return inserted.length > 0;
-  }
-  async rejectTransaction(rejection) {
-    const withMeta = await PayloadBuilder.addHashMeta(rejection);
-    const inserted = await this.rejectedTransactionsArchivist.insert([withMeta]);
-    return inserted.length > 0;
+    return result;
   }
 };
-__publicField(SimpleDeadLetterQueueRunner, "connectionTypes", ["lmdb", "mongo", "memory"]);
-__publicField(SimpleDeadLetterQueueRunner, "defaultMoniker", DeadLetterQueueRunnerMoniker);
-__publicField(SimpleDeadLetterQueueRunner, "dependencies", []);
-__publicField(SimpleDeadLetterQueueRunner, "monikers", [DeadLetterQueueRunnerMoniker]);
-__publicField(SimpleDeadLetterQueueRunner, "surface", "node");
-SimpleDeadLetterQueueRunner = __decorateClass([
-  creatableProvider6()
-], SimpleDeadLetterQueueRunner);
+__publicField(SimpleStepRewardsByStakerViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
+__publicField(SimpleStepRewardsByStakerViewer, "defaultMoniker", NetworkStakeStepRewardsByStakerViewerMoniker);
+__publicField(SimpleStepRewardsByStakerViewer, "dependencies", [BlockViewerMoniker2, FinalizationViewerMoniker3, StakeViewerMoniker3]);
+__publicField(SimpleStepRewardsByStakerViewer, "monikers", [NetworkStakeStepRewardsByStakerViewerMoniker]);
+__publicField(SimpleStepRewardsByStakerViewer, "surface", "node");
+SimpleStepRewardsByStakerViewer = __decorateClass([
+  creatableProvider7()
+], SimpleStepRewardsByStakerViewer);
 
-// src/SimpleDeadLetterQueueViewer.ts
-import {
-  exists,
-  isDefined,
-  isHash
-} from "@xylabs/sdk";
-import { isHashMeta as isHashMeta2 } from "@xyo-network/sdk-js";
+// src/SimpleStepRewards/SimpleStepRewardsByStepViewer.ts
 import {
-  DeadLetterQueueViewerMoniker,
-  isBlockRejection as isBlockRejection2,
-  isTransactionRejection as isTransactionRejection2
+  asAttoXL1 as asAttoXL13,
+  asXL1BlockRange as asXL1BlockRange3,
+  BlockViewerMoniker as BlockViewerMoniker3,
+  FinalizationViewerMoniker as FinalizationViewerMoniker4,
+  NetworkStakeStepRewardsByStepViewerMoniker,
+  StakeViewerMoniker as StakeViewerMoniker4
 } from "@xyo-network/xl1-protocol-lib";
-import { AbstractCreatableProvider as AbstractCreatableProvider6, creatableProvider as creatableProvider7 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleDeadLetterQueueViewer = class extends AbstractCreatableProvider6 {
-  moniker = SimpleDeadLetterQueueViewer.defaultMoniker;
-  get rejectedBlocksArchivist() {
-    return this.params.rejectedBlocksArchivist;
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider8,
+  blockRangeSteps as blockRangeSteps3,
+  creatableProvider as creatableProvider8,
+  toStepIdentityString as toStepIdentityString2
+} from "@xyo-network/xl1-protocol-sdk";
+var SimpleStepRewardsByStepViewer = class extends AbstractCreatableProvider8 {
+  moniker = SimpleStepRewardsByStepViewer.defaultMoniker;
+  _blockViewer;
+  _finalizationViewer;
+  _stakeViewer;
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {};
   }
-  get rejectedTransactionsArchivist() {
-    return this.params.rejectedTransactionsArchivist;
+  get blockViewer() {
+    return this._blockViewer;
   }
-  async rejectedBlocks({
-    cursor: providedCursor,
-    limit = 100,
-    rejector
-  } = {}) {
-    let cursor;
-    if (isHash(providedCursor)) {
-      const [p] = await this.rejectedBlocksArchivist.get([providedCursor]);
-      if (isDefined(p)) {
-        cursor = p._sequence;
-      }
-    }
-    const payloads = await this.rejectedBlocksArchivist.next({
-      order: "desc",
-      limit,
-      cursor
-    });
-    const rejections = payloads.filter(isHashMeta2).map((p) => isBlockRejection2(p) ? p : void 0).filter(exists);
-    if (rejector !== void 0) {
-      return rejections.filter((r) => r.rejector === rejector);
+  get finalizationViewer() {
+    return this._finalizationViewer;
+  }
+  get stakeViewer() {
+    return this._stakeViewer;
+  }
+  async bonus({ range, steps } = {}) {
+    const total = await this.total({ range, steps });
+    const earned = await this.earned({ range, steps });
+    const result = {};
+    for (const stepString of Object.keys(total)) {
+      result[stepString] = asAttoXL13(total[stepString] - (earned[stepString] ?? 0n));
     }
-    return rejections;
+    return result;
   }
-  async rejectedTransactions({
-    cursor: providedCursor,
-    limit = 100,
-    rejector
-  } = {}) {
-    let cursor;
-    if (isHash(providedCursor)) {
-      const [p] = await this.rejectedTransactionsArchivist.get([providedCursor]);
-      if (isDefined(p)) {
-        cursor = p._sequence;
-      }
+  claimed(_options) {
+    throw new Error("Method [claimed] not implemented.");
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker3);
+    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker4);
+    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker4);
+  }
+  async earned({ range, steps } = {}) {
+    const result = {};
+    const resolvedSteps = steps ?? blockRangeSteps3(asXL1BlockRange3(
+      range ?? [0, await this.finalizationViewer.headNumber()],
+      { name: "NodeStepRewardsByStepViewer" }
+    ), [3, 4, 5, 6, 7]);
+    for (const step of resolvedSteps) {
+      const stepIdentityString = toStepIdentityString2(step);
+      const reward = await networkStakeStepRewardEarned(
+        this.context,
+        this.blockViewer,
+        this.stakeViewer,
+        step
+      );
+      result[stepIdentityString] = asAttoXL13((result[stepIdentityString] ?? 0n) + reward[0]);
     }
-    const payloads = await this.rejectedTransactionsArchivist.next({
-      order: "desc",
-      limit,
-      cursor
-    });
-    const rejections = payloads.filter(isHashMeta2).map((p) => isTransactionRejection2(p) ? p : void 0).filter(exists);
-    if (rejector !== void 0) {
-      return rejections.filter((r) => r.rejector === rejector);
+    return result;
+  }
+  async total({ range, steps } = {}) {
+    const result = {};
+    const head = await this.finalizationViewer.head();
+    const resolvedSteps = steps ?? blockRangeSteps3(asXL1BlockRange3(
+      range ?? [0, head[1]],
+      { name: "NodeStepRewardsByStepViewer" }
+    ), [3, 4, 5, 6, 7]);
+    for (const step of resolvedSteps) {
+      const stepIdentityString = toStepIdentityString2(step);
+      const reward = await networkStakeStepRewardEarned(
+        this.context,
+        this.blockViewer,
+        this.stakeViewer,
+        step,
+        this.rewardMultipliers
+      );
+      result[stepIdentityString] = asAttoXL13((result[stepIdentityString] ?? 0n) + reward[0]);
     }
-    return rejections;
+    return result;
+  }
+  unclaimed(_options = {}) {
+    throw new Error("Method  [unclaimed] ot implemented.");
   }
 };
-__publicField(SimpleDeadLetterQueueViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
-__publicField(SimpleDeadLetterQueueViewer, "defaultMoniker", DeadLetterQueueViewerMoniker);
-__publicField(SimpleDeadLetterQueueViewer, "dependencies", []);
-__publicField(SimpleDeadLetterQueueViewer, "monikers", [DeadLetterQueueViewerMoniker]);
-__publicField(SimpleDeadLetterQueueViewer, "surface", "node");
-SimpleDeadLetterQueueViewer = __decorateClass([
-  creatableProvider7()
-], SimpleDeadLetterQueueViewer);
+__publicField(SimpleStepRewardsByStepViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
+__publicField(SimpleStepRewardsByStepViewer, "defaultMoniker", NetworkStakeStepRewardsByStepViewerMoniker);
+__publicField(SimpleStepRewardsByStepViewer, "dependencies", [BlockViewerMoniker3, FinalizationViewerMoniker4, StakeViewerMoniker4]);
+__publicField(SimpleStepRewardsByStepViewer, "monikers", [NetworkStakeStepRewardsByStepViewerMoniker]);
+__publicField(SimpleStepRewardsByStepViewer, "surface", "node");
+SimpleStepRewardsByStepViewer = __decorateClass([
+  creatableProvider8()
+], SimpleStepRewardsByStepViewer);
 
-// src/SimpleNetworkStakeViewer.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk";
+// src/SimpleStepRewards/SimpleStepRewardsTotalViewer.ts
+import { asAttoXL1 as asAttoXL14, NetworkStakeStepRewardsTotalViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 import {
-  FinalizationViewerMoniker as FinalizationViewerMoniker2,
-  NetworkStakeStepRewardsViewerMoniker,
-  NetworkStakeViewerMoniker as NetworkStakeViewerMoniker2,
-  StakeTotalsViewerMoniker,
-  StakeViewerMoniker as StakeViewerMoniker2
+  AbstractCreatableProvider as AbstractCreatableProvider9,
+  creatableProvider as creatableProvider9
+} from "@xyo-network/xl1-protocol-sdk";
+var SimpleStepRewardsTotalViewer = class extends AbstractCreatableProvider9 {
+  moniker = SimpleStepRewardsTotalViewer.defaultMoniker;
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {};
+  }
+  async bonus({ range } = {}) {
+    const total = await this.total({ range });
+    const earned = await this.earned({ range });
+    return asAttoXL14(total - earned);
+  }
+  claimed(_options) {
+    throw new Error("Method [claimed] not implemented.");
+  }
+  async earned(options = {}) {
+    return await this.calculateRewards(options);
+  }
+  async total(options = {}) {
+    return await this.calculateRewards(options, this.rewardMultipliers);
+  }
+  unclaimed(_options = {}) {
+    throw new Error("Method [unclaimed] not implemented.");
+  }
+  calculateRewards(_options = {}, _rewardMultipliers) {
+    throw new Error("Method  [calculateRewards] not implemented.");
+  }
+};
+__publicField(SimpleStepRewardsTotalViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
+__publicField(SimpleStepRewardsTotalViewer, "defaultMoniker", NetworkStakeStepRewardsTotalViewerMoniker);
+__publicField(SimpleStepRewardsTotalViewer, "dependencies", []);
+__publicField(SimpleStepRewardsTotalViewer, "monikers", [NetworkStakeStepRewardsTotalViewerMoniker]);
+__publicField(SimpleStepRewardsTotalViewer, "surface", "node");
+SimpleStepRewardsTotalViewer = __decorateClass([
+  creatableProvider9()
+], SimpleStepRewardsTotalViewer);
+
+// src/SimpleStepRewards/SimpleStepRewardsViewer.ts
+import { assertEx as assertEx3 } from "@ariestools/sdk";
+import {
+  BlockViewerMoniker as BlockViewerMoniker4,
+  NetworkStakeStepRewardsByPositionViewerMoniker as NetworkStakeStepRewardsByPositionViewerMoniker2,
+  NetworkStakeStepRewardsByStakerViewerMoniker as NetworkStakeStepRewardsByStakerViewerMoniker2,
+  NetworkStakeStepRewardsByStepViewerMoniker as NetworkStakeStepRewardsByStepViewerMoniker2,
+  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider7,
-  creatableProvider as creatableProvider8
+  AbstractCreatableProvider as AbstractCreatableProvider10,
+  creatableProvider as creatableProvider10
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleNetworkStakeViewer = class extends AbstractCreatableProvider7 {
-  moniker = SimpleNetworkStakeViewer.defaultMoniker;
-  _finalizationViewer;
-  _stake;
-  _stakeTotals;
-  _stepRewardsViewer;
-  get stepRewards() {
-    return assertEx5(this._stepRewardsViewer, () => "Step rewards viewer not initialized");
-  }
-  get finalizationViewer() {
-    return this._finalizationViewer;
+var SimpleStepRewardsViewer = class extends AbstractCreatableProvider10 {
+  moniker = SimpleStepRewardsViewer.defaultMoniker;
+  _blockViewer;
+  _position;
+  _staker;
+  _step;
+  get position() {
+    return assertEx3(this._position, () => "Position viewer not initialized");
   }
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers;
+  get staker() {
+    return assertEx3(this._staker, () => "Position viewer not initialized");
   }
-  get stake() {
-    return this._stake;
+  get step() {
+    return assertEx3(this._step, () => "Step viewer not initialized");
   }
-  get stakeTotals() {
-    return this._stakeTotals;
+  get total() {
+    throw new Error("Method [total] not implemented.");
   }
-  async active(blockNumber) {
-    const resolvedBlockNumber = blockNumber ?? await this.finalizationViewer.headNumber();
-    return [await this.stakeTotals.active(resolvedBlockNumber), resolvedBlockNumber];
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers;
   }
   async createHandler() {
     await super.createHandler();
-    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker2);
-    this._stake = await this.locator.getInstance(StakeViewerMoniker2);
-    this._stakeTotals = await this.locator.getInstance(StakeTotalsViewerMoniker);
-    this._stepRewardsViewer = await this.locator.getInstance(NetworkStakeStepRewardsViewerMoniker);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker4);
+    this._position = await this.locator.getInstance(NetworkStakeStepRewardsByPositionViewerMoniker2);
+    this._staker = await this.locator.getInstance(NetworkStakeStepRewardsByStakerViewerMoniker2);
+    this._step = await this.locator.getInstance(NetworkStakeStepRewardsByStepViewerMoniker2);
+  }
+  async startHandler() {
+    await super.startHandler();
+    await assertEx3(this._position, () => "Position viewer not created").start();
+    await assertEx3(this._staker, () => "Staker viewer not created").start();
+    await assertEx3(this._step, () => "Step viewer not created").start();
   }
 };
-__publicField(SimpleNetworkStakeViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
-__publicField(SimpleNetworkStakeViewer, "defaultMoniker", NetworkStakeViewerMoniker2);
-__publicField(SimpleNetworkStakeViewer, "dependencies", [
-  FinalizationViewerMoniker2,
-  NetworkStakeStepRewardsViewerMoniker,
-  StakeTotalsViewerMoniker,
-  StakeViewerMoniker2
+__publicField(SimpleStepRewardsViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
+__publicField(SimpleStepRewardsViewer, "defaultMoniker", NetworkStakeStepRewardsViewerMoniker2);
+__publicField(SimpleStepRewardsViewer, "dependencies", [
+  BlockViewerMoniker4,
+  NetworkStakeStepRewardsByPositionViewerMoniker2,
+  NetworkStakeStepRewardsByStakerViewerMoniker2,
+  NetworkStakeStepRewardsByStepViewerMoniker2
 ]);
-__publicField(SimpleNetworkStakeViewer, "monikers", [NetworkStakeViewerMoniker2]);
-__publicField(SimpleNetworkStakeViewer, "surface", "node");
-SimpleNetworkStakeViewer = __decorateClass([
-  creatableProvider8()
-], SimpleNetworkStakeViewer);
+__publicField(SimpleStepRewardsViewer, "monikers", [NetworkStakeStepRewardsViewerMoniker2]);
+__publicField(SimpleStepRewardsViewer, "surface", "node");
+SimpleStepRewardsViewer = __decorateClass([
+  creatableProvider10()
+], SimpleStepRewardsViewer);
 
-// src/SimpleStepRewards/SimpleStepRewardsByPositionViewer.ts
-import { isArray } from "@xylabs/sdk";
+// src/SimpleStepViewer.ts
 import {
-  asAttoXL1 as asAttoXL12,
-  asXL1BlockRange as asXL1BlockRange2,
-  BlockViewerMoniker as BlockViewerMoniker2,
-  FinalizationViewerMoniker as FinalizationViewerMoniker3,
-  NetworkStakeStepRewardsByPositionViewerMoniker as NetworkStakeStepRewardsByPositionViewerMoniker2,
-  StakeViewerMoniker as StakeViewerMoniker3
+  BlockViewerMoniker as BlockViewerMoniker5,
+  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker3,
+  StakeEventsViewerMoniker,
+  StakeViewerMoniker as StakeViewerMoniker5,
+  StepViewerMoniker
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider8,
-  blockRangeSteps as blockRangeSteps2,
-  creatableProvider as creatableProvider9
-} from "@xyo-network/xl1-protocol-sdk";
-
-// src/SimpleStepRewards/primitives/networkStakeStepRewardEarned.ts
-import { XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS3 } from "@xyo-network/xl1-protocol-lib";
-import { withContextCacheResponse as withContextCacheResponse3 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/SimpleStepRewards/primitives/networkStakeStepRewardEarnedForPosition.ts
-import { XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS2 } from "@xyo-network/xl1-protocol-lib";
-import {
-  externalBlockRangeFromStep as externalBlockRangeFromStep2,
-  stepRewardTotal as stepRewardTotal2,
-  weightedStakeForRangeByPosition as weightedStakeForRangeByPosition2,
-  withContextCacheResponse as withContextCacheResponse2
-} from "@xyo-network/xl1-protocol-sdk";
-async function networkStakeStepRewardEarnedForPosition(context, blockViewer, stakeEventsViewer, stepIdentity, position, rewardMultipliers = {}) {
-  const cacheKey = `${stepIdentity.block}|${stepIdentity.step}|${position.id}`;
-  return await withContextCacheResponse2(context, "networkStakeStepRewardEarnedForPosition", cacheKey, async () => {
-    const range = await externalBlockRangeFromStep2(context, blockViewer, stepIdentity);
-    const numerator = position.staked === XYO_NETWORK_STAKING_ADDRESS2 ? await weightedStakeForRangeByPosition2(
-      context,
-      blockViewer,
-      stakeEventsViewer,
-      range,
-      XYO_NETWORK_STAKING_ADDRESS2,
-      position.id
-    ) : 0n;
-    const denominator = await weightedStakeForRangeByPosition2(
-      context,
-      blockViewer,
-      stakeEventsViewer,
-      range
-    );
-    const totalReward = await stepRewardTotal2(context, blockViewer, stepIdentity, rewardMultipliers);
-    const positionReward = denominator > 0n ? totalReward * numerator / denominator : 0n;
-    const result = [positionReward, totalReward];
-    return result;
-  });
-}
-
-// src/SimpleStepRewards/primitives/networkStakeStepRewardEarned.ts
-async function networkStakeStepRewardEarned(context, blockViewer, stakeViewer, stepIdentity, rewardMultipliers = {}) {
-  const cacheKey = `${stepIdentity.block}|${stepIdentity.step}`;
-  return await withContextCacheResponse3(context, "networkStakeStepRewardEarned", cacheKey, async () => {
-    const positions = await stakeViewer.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS3);
-    const results = await Promise.all(positions.map((pos) => {
-      return networkStakeStepRewardEarnedForPosition(
-        context,
-        blockViewer,
-        stakeViewer.stakeEvents,
-        stepIdentity,
-        pos,
-        rewardMultipliers
-      );
-    }));
-    const numerator = results.reduce((acc, [positionReward]) => acc + positionReward, 0n);
-    const result = results.length > 0 ? [numerator, results[0][1]] : [0n, 0n];
-    return result;
-  });
-}
-
-// src/SimpleStepRewards/primitives/networkStakeStepRewardEarnedForStaker.ts
-import { XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS4 } from "@xyo-network/xl1-protocol-lib";
-import {
-  toStepIdentityString as toStepIdentityString2,
-  withContextCacheResponse as withContextCacheResponse4
+  AbstractCreatableProvider as AbstractCreatableProvider11,
+  creatableProvider as creatableProvider11,
+  externalBlockRangeFromStep as externalBlockRangeFromStep2
 } from "@xyo-network/xl1-protocol-sdk";
-async function networkStakeStepRewardEarnedForStaker(context, blockViewer, stakeViewer, stepIdentity, staker, rewardMultipliers = {}) {
-  const stepId = toStepIdentityString2(stepIdentity);
-  return await withContextCacheResponse4(context, "networkStakeStepRewardEarnedForStaker", `${stepId}-${staker}`, async () => {
-    const stakes = await stakeViewer.stakesByStaker(staker);
-    const positions = stakes.filter((pos) => pos.staked === XYO_NETWORK_STAKING_ADDRESS4);
-    const results = await Promise.all(positions.map((pos) => {
-      return networkStakeStepRewardEarnedForPosition(
-        context,
-        blockViewer,
-        stakeViewer.stakeEvents,
-        stepIdentity,
-        pos,
-        rewardMultipliers
-      );
-    }));
-    const numerator = results.reduce((acc, [positionReward]) => acc + positionReward, 0n);
-    const result = results.length > 0 ? [numerator, results[0][1]] : [0n, 0n];
-    return result;
-  });
-}
-
-// src/SimpleStepRewards/SimpleStepRewardsByPositionViewer.ts
-var SimpleStepRewardsByPositionViewer = class extends AbstractCreatableProvider8 {
-  moniker = SimpleStepRewardsByPositionViewer.defaultMoniker;
+var SimpleStepViewer = class extends AbstractCreatableProvider11 {
+  moniker = SimpleStepViewer.defaultMoniker;
   _blockViewer;
-  _finalizationViewer;
+  _networkStakeStepRewardsViewer;
+  _stakeEventsViewer;
   _stakeViewer;
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers ?? {};
+  get rewards() {
+    return this._networkStakeStepRewardsViewer;
   }
   get blockViewer() {
     return this._blockViewer;
   }
-  get finalizationViewer() {
-    return this._finalizationViewer;
+  get stakeEventsViewer() {
+    return this._stakeEventsViewer;
   }
   get stakeViewer() {
     return this._stakeViewer;
   }
-  async bonus({ range, positions } = {}) {
-    const total = await this.total({ range, positions });
-    const earned = await this.earned({ range, positions });
-    const result = {};
-    for (const key of Object.keys(total)) {
-      const pos = Number(key);
-      result[pos] = asAttoXL12(total[pos] - (earned[pos] ?? 0n));
-    }
-    return result;
-  }
-  claimed(_options) {
-    throw new Error("Method [claimed] not implemented.");
-  }
   async createHandler() {
     await super.createHandler();
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker2);
-    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker3);
-    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker3);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker5);
+    this._networkStakeStepRewardsViewer = await this.locator.getInstance(NetworkStakeStepRewardsViewerMoniker3);
+    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker5);
+    this._stakeEventsViewer = await this.locator.getInstance(StakeEventsViewerMoniker);
   }
-  async earned({ range, positions } = {}) {
-    return await this.calculateRewards({ range, positions });
+  async positionCount(step) {
+    const externalRange = await externalBlockRangeFromStep2(this.context, this.blockViewer, step);
+    const positionCount = await this.stakeEventsViewer.positionCount(externalRange);
+    return positionCount;
   }
-  async total({ range, positions } = {}) {
-    return await this.calculateRewards({ range, positions }, this.rewardMultipliers);
+  // TODO: Implement paging
+  async positions(step, _options) {
+    const count = await this.positionCount(step);
+    const externalRange = await externalBlockRangeFromStep2(this.context, this.blockViewer, step);
+    const allPositions = await Promise.all(Array.from({ length: count + 1 }, (_, i) => i).map(async (id) => this.stakeViewer.stakeById(id)));
+    return allPositions.filter((pos) => pos.addBlock <= externalRange[1] && (pos.removeBlock === 0 || pos.removeBlock > externalRange[0]));
   }
-  unclaimed(_options = {}) {
-    throw new Error("Method [unclaimed] not implemented.");
+  randomizer(_step) {
+    throw new Error("Method [randomizer] not implemented.");
   }
-  async calculateRewards({ range, positions } = {}, rewardMultipliers) {
-    const result = {};
-    const head = await this.finalizationViewer.head();
-    const steps = blockRangeSteps2(asXL1BlockRange2(
-      range ?? [0, head[1]],
-      { name: "NodeStepRewardsByPositionViewer" }
-    ), [3, 4, 5, 6, 7]);
-    for (const step of steps) {
-      if (isArray(positions)) {
-        for (const positionId of positions) {
-          const position = await this.stakeViewer.stakeById(positionId);
-          const reward = await networkStakeStepRewardEarnedForPosition(
-            this.context,
-            this.blockViewer,
-            this.stakeViewer.stakeEvents,
-            step,
-            position,
-            rewardMultipliers
-          );
-          result[positionId] = asAttoXL12((result[positionId] ?? 0n) + reward[0]);
-        }
-      }
-    }
-    return result;
+  stake(_step) {
+    throw new Error("Method [stake] not implemented.");
+  }
+  stakerCount(_step) {
+    throw new Error("Method [stakerCount] not implemented.");
+  }
+  stakers(_step, _options) {
+    throw new Error("Method [stakers] not implemented.");
+  }
+  weight(_step, _positionId) {
+    throw new Error("Method [weight] not implemented.");
   }
 };
-__publicField(SimpleStepRewardsByPositionViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
-__publicField(SimpleStepRewardsByPositionViewer, "defaultMoniker", NetworkStakeStepRewardsByPositionViewerMoniker2);
-__publicField(SimpleStepRewardsByPositionViewer, "dependencies", [BlockViewerMoniker2, FinalizationViewerMoniker3, StakeViewerMoniker3]);
-__publicField(SimpleStepRewardsByPositionViewer, "monikers", [NetworkStakeStepRewardsByPositionViewerMoniker2]);
-__publicField(SimpleStepRewardsByPositionViewer, "surface", "node");
-SimpleStepRewardsByPositionViewer = __decorateClass([
-  creatableProvider9()
-], SimpleStepRewardsByPositionViewer);
+__publicField(SimpleStepViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
+__publicField(SimpleStepViewer, "defaultMoniker", StepViewerMoniker);
+__publicField(SimpleStepViewer, "dependencies", [
+  BlockViewerMoniker5,
+  NetworkStakeStepRewardsViewerMoniker3,
+  StakeViewerMoniker5,
+  StakeEventsViewerMoniker
+]);
+__publicField(SimpleStepViewer, "monikers", [StepViewerMoniker]);
+__publicField(SimpleStepViewer, "surface", "node");
+SimpleStepViewer = __decorateClass([
+  creatableProvider11()
+], SimpleStepViewer);
 
-// src/SimpleStepRewards/SimpleStepRewardsByStakerViewer.ts
-import { isArray as isArray2 } from "@xylabs/sdk";
+// src/SimpleXyoViewer.ts
 import {
-  asAttoXL1 as asAttoXL13,
-  asXL1BlockRange as asXL1BlockRange3,
-  BlockViewerMoniker as BlockViewerMoniker3,
-  FinalizationViewerMoniker as FinalizationViewerMoniker4,
-  NetworkStakeStepRewardsByStakerViewerMoniker,
-  StakeViewerMoniker as StakeViewerMoniker4
+  assertEx as assertEx4,
+  toAddress
+} from "@ariestools/sdk";
+import {
+  AccountBalanceViewerMoniker,
+  asAttoXL1 as asAttoXL15,
+  asXL1BlockRange as asXL1BlockRange4,
+  BlockViewerMoniker as BlockViewerMoniker6,
+  ChainContractViewerMoniker,
+  FinalizationViewerMoniker as FinalizationViewerMoniker5,
+  MempoolViewerMoniker,
+  NetworkStakeStepRewardsByPositionViewerMoniker as NetworkStakeStepRewardsByPositionViewerMoniker3,
+  NetworkStakeViewerMoniker as NetworkStakeViewerMoniker2,
+  StakeViewerMoniker as StakeViewerMoniker6,
+  StepViewerMoniker as StepViewerMoniker2,
+  TimeSyncViewerMoniker,
+  TransactionViewerMoniker,
+  XYO_NETWORK_STAKING_ADDRESS as XYO_NETWORK_STAKING_ADDRESS4,
+  XYO_ZERO_ADDRESS,
+  XyoViewerMoniker as XyoViewerMoniker3
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider9,
-  blockRangeSteps as blockRangeSteps3,
-  creatableProvider as creatableProvider10
+  AbstractCreatableProvider as AbstractCreatableProvider12,
+  allStakersForStep,
+  blockRangeSteps as blockRangeSteps4,
+  creatableProvider as creatableProvider12,
+  externalBlockRangeFromStep as externalBlockRangeFromStep3,
+  externalBlockRangeFromXL1BlockRange,
+  networkStakeStepRewardPositionWeight,
+  stepRewardTotal as stepRewardTotal2,
+  toStepIdentityString as toStepIdentityString3,
+  weightedStakeForRangeByPosition as weightedStakeForRangeByPosition2,
+  withContextCacheResponse as withContextCacheResponse4
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepRewardsByStakerViewer = class extends AbstractCreatableProvider9 {
-  moniker = SimpleStepRewardsByStakerViewer.defaultMoniker;
+var SimpleXyoViewer = class extends AbstractCreatableProvider12 {
+  moniker = SimpleXyoViewer.defaultMoniker;
+  _tracer;
+  _accountBalanceViewer;
   _blockViewer;
+  _chainContractViewer;
+  _chainId;
   _finalizationViewer;
+  _mempoolViewer;
+  _networkStakeViewer;
+  _networkStepRewardsByPositionViewer;
+  _rewardMultipliers;
   _stakeViewer;
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers ?? {};
+  _stepViewer;
+  _timeSyncViewer;
+  _transaction;
+  get account() {
+    return { balance: this._accountBalanceViewer };
   }
-  get blockViewer() {
+  get block() {
     return this._blockViewer;
   }
-  get finalizationViewer() {
+  get chainContractViewer() {
+    return this._chainContractViewer;
+  }
+  get finalization() {
     return this._finalizationViewer;
   }
-  get stakeViewer() {
-    return this._stakeViewer;
+  get mempool() {
+    return this._mempoolViewer;
   }
-  async bonus({ range, stakers } = {}) {
-    const total = await this.total({ range, stakers });
-    const earned = await this.earned({ range, stakers });
-    const result = {};
-    for (const staker of Object.keys(total)) {
-      result[staker] = asAttoXL13(total[staker] - (earned[staker] ?? 0n));
-    }
-    return result;
+  get networkStake() {
+    return this._networkStakeViewer;
   }
-  claimed(_options) {
-    throw new Error("Method [claimed] not implemented.");
+  get stake() {
+    return this._stakeViewer;
   }
-  async createHandler() {
-    await super.createHandler();
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker3);
-    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker4);
-    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker4);
+  get step() {
+    return this._stepViewer;
   }
-  async earned(options = {}) {
-    return await this.calculateRewards(options);
+  get time() {
+    return this._timeSyncViewer;
   }
-  async total(options = {}) {
-    return await this.calculateRewards(options, this.rewardMultipliers);
+  get transaction() {
+    return this._transaction;
   }
-  unclaimed(_options = {}) {
-    throw new Error("Method [unclaimed] not implemented.");
+  get finalizationViewer() {
+    return this._finalizationViewer;
   }
-  async calculateRewards({ range, stakers } = {}, rewardMultipliers) {
-    const result = {};
-    const steps = blockRangeSteps3(asXL1BlockRange3(
-      range ?? [0, await this.finalizationViewer.headNumber()],
-      { name: "NodeStepRewardsByStakerViewer" }
-    ), [3, 4, 5, 6, 7]);
-    for (const step of steps) {
-      if (isArray2(stakers)) {
-        for (const staker of stakers) {
-          const reward = await networkStakeStepRewardEarnedForStaker(
-            this.context,
-            this.blockViewer,
-            this.stakeViewer,
-            step,
-            staker,
-            rewardMultipliers
-          );
-          result[staker] = asAttoXL13((result[staker] ?? 0n) + reward[0]);
-        }
-      }
-    }
-    return result;
+  get initRewardsCache() {
+    return this.params.initRewardsCache ?? true;
+  }
+  get networkStepRewardsByPositionViewer() {
+    return this._networkStepRewardsByPositionViewer;
   }
-};
-__publicField(SimpleStepRewardsByStakerViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
-__publicField(SimpleStepRewardsByStakerViewer, "defaultMoniker", NetworkStakeStepRewardsByStakerViewerMoniker);
-__publicField(SimpleStepRewardsByStakerViewer, "dependencies", [BlockViewerMoniker3, FinalizationViewerMoniker4, StakeViewerMoniker4]);
-__publicField(SimpleStepRewardsByStakerViewer, "monikers", [NetworkStakeStepRewardsByStakerViewerMoniker]);
-__publicField(SimpleStepRewardsByStakerViewer, "surface", "node");
-SimpleStepRewardsByStakerViewer = __decorateClass([
-  creatableProvider10()
-], SimpleStepRewardsByStakerViewer);
-
-// src/SimpleStepRewards/SimpleStepRewardsByStepViewer.ts
-import {
-  asAttoXL1 as asAttoXL14,
-  asXL1BlockRange as asXL1BlockRange4,
-  BlockViewerMoniker as BlockViewerMoniker4,
-  FinalizationViewerMoniker as FinalizationViewerMoniker5,
-  NetworkStakeStepRewardsByStepViewerMoniker,
-  StakeViewerMoniker as StakeViewerMoniker5
-} from "@xyo-network/xl1-protocol-lib";
-import {
-  AbstractCreatableProvider as AbstractCreatableProvider10,
-  blockRangeSteps as blockRangeSteps4,
-  creatableProvider as creatableProvider11,
-  toStepIdentityString as toStepIdentityString3
-} from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepRewardsByStepViewer = class extends AbstractCreatableProvider10 {
-  moniker = SimpleStepRewardsByStepViewer.defaultMoniker;
-  _blockViewer;
-  _finalizationViewer;
-  _stakeViewer;
   get rewardMultipliers() {
-    return this.params.rewardMultipliers ?? {};
+    this._rewardMultipliers = this._rewardMultipliers ?? this.params.rewardMultipliers ?? {};
+    return this._rewardMultipliers;
   }
-  get blockViewer() {
-    return this._blockViewer;
+  async accountBalance(address, config = {}) {
+    return await this.account.balance.accountBalance(address, config);
   }
-  get finalizationViewer() {
-    return this._finalizationViewer;
+  async accountBalanceHistory(address, config = {}) {
+    return await this.account.balance.accountBalanceHistory(address, config);
   }
-  get stakeViewer() {
-    return this._stakeViewer;
+  async blockByHash(hash) {
+    return await this.block.blockByHash(hash);
   }
-  async bonus({ range, steps } = {}) {
-    const total = await this.total({ range, steps });
-    const earned = await this.earned({ range, steps });
-    const result = {};
-    for (const stepString of Object.keys(total)) {
-      result[stepString] = asAttoXL14(total[stepString] - (earned[stepString] ?? 0n));
-    }
-    return result;
+  async blockByNumber(blockNumber) {
+    return await this.block.blockByNumber(blockNumber);
   }
-  claimed(_options) {
-    throw new Error("Method [claimed] not implemented.");
+  async blocksByHash(hash, limit = 10) {
+    return await this.block.blocksByHash(hash, limit);
+  }
+  async blocksByNumber(blockNumber, limit = 10) {
+    return await this.block.blocksByNumber(blockNumber, limit);
+  }
+  async blocksByStep(stepLevel, stepIndex) {
+    return await this.block.blocksByStep(stepLevel, stepIndex);
+  }
+  async chainId(blockNumber = "latest") {
+    return await this.spanAsync("SimpleXyoViewer:chainId", async () => {
+      const chainId = assertEx4(
+        blockNumber === "latest" ? this._chainId : await this.chainContractViewer.chainIdAtBlockNumber(blockNumber),
+        () => `Could not find block for chainId at block ${blockNumber}`
+      );
+      return chainId;
+    }, this.context);
   }
   async createHandler() {
     await super.createHandler();
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker4);
+    this._accountBalanceViewer = await this.locator.getInstance(AccountBalanceViewerMoniker);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker6);
+    this._chainContractViewer = await this.locator.getInstance(ChainContractViewerMoniker);
     this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker5);
-    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker5);
+    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker);
+    this._networkStakeViewer = await this.locator.getInstance(NetworkStakeViewerMoniker2);
+    this._networkStepRewardsByPositionViewer = await this.locator.getInstance(NetworkStakeStepRewardsByPositionViewerMoniker3);
+    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker6);
+    this._stepViewer = await this.locator.getInstance(StepViewerMoniker2);
+    this._timeSyncViewer = await this.locator.getInstance(TimeSyncViewerMoniker);
+    this._transaction = await this.locator.getInstance(TransactionViewerMoniker);
+    this._chainId = await this._chainContractViewer.chainId();
   }
-  async earned({ range, steps } = {}) {
-    const result = {};
-    const resolvedSteps = steps ?? blockRangeSteps4(asXL1BlockRange4(
-      range ?? [0, await this.finalizationViewer.headNumber()],
-      { name: "NodeStepRewardsByStepViewer" }
-    ), [3, 4, 5, 6, 7]);
-    for (const step of resolvedSteps) {
-      const stepIdentityString = toStepIdentityString3(step);
-      const reward = await networkStakeStepRewardEarned(
-        this.context,
-        this.blockViewer,
-        this.stakeViewer,
-        step
-      );
-      result[stepIdentityString] = asAttoXL14((result[stepIdentityString] ?? 0n) + reward[0]);
-    }
-    return result;
+  async currentBlock() {
+    return await this.block.currentBlock();
   }
-  async total({ range, steps } = {}) {
-    const result = {};
-    const head = await this.finalizationViewer.head();
-    const resolvedSteps = steps ?? blockRangeSteps4(asXL1BlockRange4(
-      range ?? [0, head[1]],
-      { name: "NodeStepRewardsByStepViewer" }
-    ), [3, 4, 5, 6, 7]);
-    for (const step of resolvedSteps) {
-      const stepIdentityString = toStepIdentityString3(step);
-      const reward = await networkStakeStepRewardEarned(
-        this.context,
-        this.blockViewer,
-        this.stakeViewer,
-        step,
-        this.rewardMultipliers
-      );
-      result[stepIdentityString] = asAttoXL14((result[stepIdentityString] ?? 0n) + reward[0]);
-    }
-    return result;
+  async currentBlockHash() {
+    return await this.block.currentBlockHash();
   }
-  unclaimed(_options = {}) {
-    throw new Error("Method  [unclaimed] ot implemented.");
+  async currentBlockNumber() {
+    return await this.block.currentBlockNumber();
   }
-};
-__publicField(SimpleStepRewardsByStepViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
-__publicField(SimpleStepRewardsByStepViewer, "defaultMoniker", NetworkStakeStepRewardsByStepViewerMoniker);
-__publicField(SimpleStepRewardsByStepViewer, "dependencies", [BlockViewerMoniker4, FinalizationViewerMoniker5, StakeViewerMoniker5]);
-__publicField(SimpleStepRewardsByStepViewer, "monikers", [NetworkStakeStepRewardsByStepViewerMoniker]);
-__publicField(SimpleStepRewardsByStepViewer, "surface", "node");
-SimpleStepRewardsByStepViewer = __decorateClass([
-  creatableProvider11()
-], SimpleStepRewardsByStepViewer);
-
-// src/SimpleStepRewards/SimpleStepRewardsTotalViewer.ts
-import { asAttoXL1 as asAttoXL15, NetworkStakeStepRewardsTotalViewerMoniker } from "@xyo-network/xl1-protocol-lib";
-import {
-  AbstractCreatableProvider as AbstractCreatableProvider11,
-  creatableProvider as creatableProvider12
-} from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepRewardsTotalViewer = class extends AbstractCreatableProvider11 {
-  moniker = SimpleStepRewardsTotalViewer.defaultMoniker;
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers ?? {};
+  forkHistory() {
+    throw new Error("Method [forkHistory] not implemented.");
+  }
+  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.");
+  }
+  async networkStakeStepRewardForPosition(position, range) {
+    const cacheKey = `${position}|${range[0]}-${range[1]}`;
+    return await withContextCacheResponse4(this.context, "SimpleXyoViewer:networkStakeStepRewardForPosition", cacheKey, async () => {
+      const externalRange = await externalBlockRangeFromXL1BlockRange(this.context, this.block, range);
+      const positionCount = await this.stake.stakeEvents.positionCount(externalRange);
+      if (positionCount === 0) {
+        return [asAttoXL15(0n), asAttoXL15(0n)];
+      }
+      const steps = blockRangeSteps4(range, [3, 4, 5, 6, 7]);
+      const rewards = await Promise.all(steps.map((step) => this.networkStakeStepRewardForStepForPosition(step, position)));
+      const positionReward = asAttoXL15(rewards.reduce((a, b) => a + b[0], 0n));
+      const totalReward = asAttoXL15(rewards.reduce((a, b) => a + b[1], 0n));
+      return [positionReward, totalReward];
+    });
+  }
+  async networkStakeStepRewardForStep(stepContext) {
+    return await stepRewardTotal2(this.context, this.block, stepContext, this.rewardMultipliers);
+  }
+  async networkStakeStepRewardForStepForPosition(stepIdentity, position) {
+    const stepIdentityString = toStepIdentityString3(stepIdentity);
+    const cacheKey = `${stepIdentityString}|${position}`;
+    return await withContextCacheResponse4(this.context, "SimpleXyoViewer:networkStakeStepRewardForStepForPosition", cacheKey, async () => {
+      const range = await externalBlockRangeFromStep3(this.context, this.block, stepIdentity);
+      const stake = await this.stakeById(position);
+      const numerator = stake.staked === XYO_NETWORK_STAKING_ADDRESS4 ? await weightedStakeForRangeByPosition2(this.context, this.block, this.stake.stakeEvents, range, XYO_NETWORK_STAKING_ADDRESS4, position) : 0n;
+      const denominator = await this.stepWeightedDenominator(stepIdentity);
+      const totalReward = await this.networkStakeStepRewardForStep(stepIdentity);
+      const positionReward = asAttoXL15(denominator > 0n ? totalReward * numerator / denominator : 0n);
+      const result = [positionReward, totalReward];
+      return result;
+    });
+  }
+  async networkStakeStepRewardPoolRewards(step) {
+    const stakes = await this.stake.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS4);
+    const rewards = [];
+    for (const stake of stakes) {
+      rewards.push([stake.staker, await this.networkStakeStepRewardForStepForPosition(
+        step,
+        stake.id
+      )]);
+    }
+    const result = {};
+    for (const [staker, reward] of rewards) {
+      result[staker] = asAttoXL15((result[staker] ?? 0n) + reward[0]);
+    }
+    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v > 0n));
+    return filtered;
   }
-  async bonus({ range } = {}) {
-    const total = await this.total({ range });
-    const earned = await this.earned({ range });
-    return asAttoXL15(total - earned);
+  networkStakeStepRewardPoolShares(_context) {
+    throw new Error("Method [networkStakeStepRewardPoolShares] not implemented.");
   }
-  claimed(_options) {
-    throw new Error("Method [claimed] not implemented.");
+  async networkStakeStepRewardPositionWeight(stepContext, position) {
+    return await networkStakeStepRewardPositionWeight(this.context, this.block, this.stake.stakeEvents, stepContext, position);
   }
-  async earned(options = {}) {
-    return await this.calculateRewards(options);
+  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardPotentialPositionLoss] not implemented.");
   }
-  async total(options = {}) {
-    return await this.calculateRewards(options, this.rewardMultipliers);
+  networkStakeStepRewardRandomizer(_context) {
+    throw new Error("Method [networkStakeStepRewardRandomizer] not implemented.");
   }
-  unclaimed(_options = {}) {
-    throw new Error("Method [unclaimed] not implemented.");
+  async networkStakeStepRewardStakerCount(stepContext) {
+    return Object.keys(await allStakersForStep(
+      this.context,
+      this.block,
+      this.stake.stakeEvents,
+      stepContext,
+      XYO_NETWORK_STAKING_ADDRESS4
+    )).length;
   }
-  calculateRewards(_options = {}, _rewardMultipliers) {
-    throw new Error("Method  [calculateRewards] not implemented.");
+  networkStakeStepRewardUnclaimedByAddress(_address) {
+    throw new Error("Method [networkStakeStepRewardUnclaimedByAddress] not implemented.");
   }
-};
-__publicField(SimpleStepRewardsTotalViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
-__publicField(SimpleStepRewardsTotalViewer, "defaultMoniker", NetworkStakeStepRewardsTotalViewerMoniker);
-__publicField(SimpleStepRewardsTotalViewer, "dependencies", []);
-__publicField(SimpleStepRewardsTotalViewer, "monikers", [NetworkStakeStepRewardsTotalViewerMoniker]);
-__publicField(SimpleStepRewardsTotalViewer, "surface", "node");
-SimpleStepRewardsTotalViewer = __decorateClass([
-  creatableProvider12()
-], SimpleStepRewardsTotalViewer);
-
-// src/SimpleStepRewards/SimpleStepRewardsViewer.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk";
-import {
-  BlockViewerMoniker as BlockViewerMoniker5,
-  NetworkStakeStepRewardsByPositionViewerMoniker as NetworkStakeStepRewardsByPositionViewerMoniker3,
-  NetworkStakeStepRewardsByStakerViewerMoniker as NetworkStakeStepRewardsByStakerViewerMoniker2,
-  NetworkStakeStepRewardsByStepViewerMoniker as NetworkStakeStepRewardsByStepViewerMoniker2,
-  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
-import {
-  AbstractCreatableProvider as AbstractCreatableProvider12,
-  creatableProvider as creatableProvider13
-} from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepRewardsViewer = class extends AbstractCreatableProvider12 {
-  moniker = SimpleStepRewardsViewer.defaultMoniker;
-  _blockViewer;
-  _position;
-  _staker;
-  _step;
-  get position() {
-    return assertEx6(this._position, () => "Position viewer not initialized");
+  networkStakeStepRewardWeightForAddress(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardWeightForAddress] not implemented.");
   }
-  get staker() {
-    return assertEx6(this._staker, () => "Position viewer not initialized");
+  async networkStakeStepRewardsForPosition(position, range) {
+    const steps = blockRangeSteps4(range, [3, 4, 5, 6, 7, 8]);
+    const rewards = await Promise.all(steps.map(async (step) => {
+      return [toStepIdentityString3(step), await this.networkStakeStepRewardForStepForPosition(step, position)];
+    }));
+    const result = Object.fromEntries(rewards);
+    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v[0] > 0n));
+    return filtered;
   }
-  get step() {
-    return assertEx6(this._step, () => "Step viewer not initialized");
+  async networkStakeStepRewardsForRange(range) {
+    return await this.spanAsync("networkStakeStepRewardsForRange", async () => {
+      const steps = blockRangeSteps4(range, [3, 4, 5, 6, 7, 8]);
+      const rewards = await Promise.all(steps.map(async (step) => {
+        return await this.networkStakeStepRewardForStep(step);
+      }));
+      return asAttoXL15(rewards.reduce((a, b) => a + b, 0n));
+    }, this.context);
   }
-  get total() {
-    throw new Error("Method [total] not implemented.");
+  async networkStakeStepRewardsForStepLevel(stepLevel, range) {
+    const steps = blockRangeSteps4(range, [stepLevel]);
+    const rewards = await Promise.all(steps.map(async (step) => {
+      return await this.networkStakeStepRewardForStep(step);
+    }));
+    return asAttoXL15(rewards.reduce((a, b) => a + b, 0n));
   }
-  get rewardMultipliers() {
-    return this.params.rewardMultipliers;
+  payloadByHash(_hash) {
+    throw new Error("Method [payloadByHash] not implemented.");
   }
-  async createHandler() {
-    await super.createHandler();
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker5);
-    this._position = await this.locator.getInstance(NetworkStakeStepRewardsByPositionViewerMoniker3);
-    this._staker = await this.locator.getInstance(NetworkStakeStepRewardsByStakerViewerMoniker2);
-    this._step = await this.locator.getInstance(NetworkStakeStepRewardsByStepViewerMoniker2);
+  payloadsByHash(_hashes) {
+    throw new Error("Method [payloadsByHash] not implemented.");
   }
-  async startHandler() {
-    await super.startHandler();
-    await assertEx6(this._position, () => "Position viewer not created").start();
-    await assertEx6(this._staker, () => "Staker viewer not created").start();
-    await assertEx6(this._step, () => "Step viewer not created").start();
+  async rate(range, timeUnit) {
+    return await this.block.rate(range, timeUnit);
   }
-};
-__publicField(SimpleStepRewardsViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
-__publicField(SimpleStepRewardsViewer, "defaultMoniker", NetworkStakeStepRewardsViewerMoniker2);
-__publicField(SimpleStepRewardsViewer, "dependencies", [
-  BlockViewerMoniker5,
-  NetworkStakeStepRewardsByPositionViewerMoniker3,
-  NetworkStakeStepRewardsByStakerViewerMoniker2,
-  NetworkStakeStepRewardsByStepViewerMoniker2
-]);
-__publicField(SimpleStepRewardsViewer, "monikers", [NetworkStakeStepRewardsViewerMoniker2]);
-__publicField(SimpleStepRewardsViewer, "surface", "node");
-SimpleStepRewardsViewer = __decorateClass([
-  creatableProvider13()
-], SimpleStepRewardsViewer);
-
-// src/SimpleStepViewer.ts
-import {
-  BlockViewerMoniker as BlockViewerMoniker6,
-  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker3,
-  StakeEventsViewerMoniker,
-  StakeViewerMoniker as StakeViewerMoniker6,
-  StepViewerMoniker as StepViewerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
-import {
-  AbstractCreatableProvider as AbstractCreatableProvider13,
-  creatableProvider as creatableProvider14,
-  externalBlockRangeFromStep as externalBlockRangeFromStep3
-} from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepViewer = class extends AbstractCreatableProvider13 {
-  moniker = SimpleStepViewer.defaultMoniker;
-  _blockViewer;
-  _networkStakeStepRewardsViewer;
-  _stakeEventsViewer;
-  _stakeViewer;
-  get rewards() {
-    return this._networkStakeStepRewardsViewer;
+  async stakeById(id) {
+    return await this.stake.stakeById(id);
   }
-  get blockViewer() {
-    return this._blockViewer;
+  async stakeByStaker(staker, slot) {
+    return await this.stake.stakeByStaker(staker, slot);
   }
-  get stakeEventsViewer() {
-    return this._stakeEventsViewer;
+  async stakedByStaker(staker) {
+    const result = /* @__PURE__ */ new Set();
+    let slot = 0;
+    while (true) {
+      try {
+        const ethStake = await this.stake.stakeByStaker(staker, slot);
+        result.add(toAddress(ethStake.staked));
+        slot++;
+      } catch {
+        break;
+      }
+    }
+    return [...result];
   }
-  get stakeViewer() {
-    return this._stakeViewer;
+  async stakesByStaked(staked) {
+    return await this.stake.stakesByStaked(staked);
   }
-  async createHandler() {
-    await super.createHandler();
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker6);
-    this._networkStakeStepRewardsViewer = await this.locator.getInstance(NetworkStakeStepRewardsViewerMoniker3);
-    this._stakeViewer = await this.locator.getInstance(StakeViewerMoniker6);
-    this._stakeEventsViewer = await this.locator.getInstance(StakeEventsViewerMoniker);
+  async stakesByStaker(staker) {
+    return await this.stake.stakesByStaker(staker);
   }
-  async positionCount(step) {
-    const externalRange = await externalBlockRangeFromStep3(this.context, this.blockViewer, step);
-    const positionCount = await this.stakeEventsViewer.positionCount(externalRange);
-    return positionCount;
+  async stepSizeRate(start, stepSizeIndex, count, timeUnit) {
+    return await this.block.stepSizeRate(start, stepSizeIndex, count, timeUnit);
   }
-  // TODO: Implement paging
-  async positions(step, _options) {
-    const count = await this.positionCount(step);
-    const externalRange = await externalBlockRangeFromStep3(this.context, this.blockViewer, step);
-    const allPositions = await Promise.all(Array.from({ length: count + 1 }, (_, i) => i).map(async (id) => this.stakeViewer.stakeById(id)));
-    return allPositions.filter((pos) => pos.addBlock <= externalRange[1] && (pos.removeBlock === 0 || pos.removeBlock > externalRange[0]));
+  async timeDurationRate(timeConfig, startBlock, timeUnit, toleranceMs, maxAttempts) {
+    return await this.block.timeDurationRate(timeConfig, startBlock, timeUnit, toleranceMs, maxAttempts);
   }
-  randomizer(_step) {
-    throw new Error("Method [randomizer] not implemented.");
+  async transactionByBlockHashAndIndex(blockHash, transactionIndex = 0) {
+    return await this.transaction.byBlockHashAndIndex(blockHash, transactionIndex);
   }
-  stake(_step) {
-    throw new Error("Method [stake] not implemented.");
+  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex = 0) {
+    return await this.transaction.byBlockNumberAndIndex(blockNumber, transactionIndex);
   }
-  stakerCount(_step) {
-    throw new Error("Method [stakerCount] not implemented.");
+  async transactionByHash(transactionHash) {
+    return await this.transaction.byHash(transactionHash);
   }
-  stakers(_step, _options) {
-    throw new Error("Method [stakers] not implemented.");
+  async startHandler() {
+    try {
+      const currentBlockNumber = await this.currentBlockNumber();
+      await this.account.balance.accountBalance(XYO_ZERO_ADDRESS);
+      if (this.initRewardsCache) {
+        const externalRange = await externalBlockRangeFromXL1BlockRange(
+          this.context,
+          this.block,
+          asXL1BlockRange4([0, currentBlockNumber], { name: "startHandler" })
+        );
+        const positionCount = await this.stake.stakeEvents.positionCount(externalRange);
+        this.logger?.debug(`SimpleXyoViewer: Precomputing networkStakeStepRewardForPosition up to position ${positionCount - 1}`);
+        const positions = Array.from(
+          { length: positionCount },
+          (_, i) => i
+        );
+        while (positions.length > 0) {
+          const batch = positions.splice(0, 10);
+          this.logger?.debug(`SimpleXyoViewer: Precomputing networkStakeStepRewardForPosition for positions ${batch.at(0)} - ${batch.at(-1)}`);
+          await Promise.all(batch.map(async (_, position) => await this.networkStakeStepRewardForPosition(
+            position,
+            asXL1BlockRange4([0, currentBlockNumber], { name: "startHandler" })
+          )));
+        }
+        this.logger?.debug(`SimpleXyoViewer: Precomputed networkStakeStepRewardForPosition up to position ${positionCount - 1}`);
+      }
+    } catch (ex) {
+      this.logger?.error(`SimpleXyoViewer: Error during startHandler initialization: ${ex.message}`);
+      this.logger?.error(ex.stack ?? "<No Stack>");
+      throw ex;
+    }
   }
-  weight(_step, _positionId) {
-    throw new Error("Method [weight] not implemented.");
+  async stepWeightedDenominator(stepIdentity, staked) {
+    const cacheKey = toStepIdentityString3(stepIdentity);
+    return await withContextCacheResponse4(this.context, "NodeXyoViewer-networkStakeStepRewardForStepForPosition-denominator", cacheKey, async () => {
+      const range = await externalBlockRangeFromStep3(this.context, this.block, stepIdentity);
+      return await weightedStakeForRangeByPosition2(this.context, this.block, this.stake.stakeEvents, range, staked);
+    });
   }
 };
-__publicField(SimpleStepViewer, "connectionTypes", ["lmdb", "mongo", "memory", "rpc"]);
-__publicField(SimpleStepViewer, "defaultMoniker", StepViewerMoniker2);
-__publicField(SimpleStepViewer, "dependencies", [
+__publicField(SimpleXyoViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
+__publicField(SimpleXyoViewer, "defaultMoniker", XyoViewerMoniker3);
+__publicField(SimpleXyoViewer, "dependencies", [
+  AccountBalanceViewerMoniker,
   BlockViewerMoniker6,
-  NetworkStakeStepRewardsViewerMoniker3,
+  ChainContractViewerMoniker,
+  FinalizationViewerMoniker5,
+  MempoolViewerMoniker,
+  NetworkStakeViewerMoniker2,
+  NetworkStakeStepRewardsByPositionViewerMoniker3,
   StakeViewerMoniker6,
-  StakeEventsViewerMoniker
+  StepViewerMoniker2,
+  TimeSyncViewerMoniker,
+  TransactionViewerMoniker
 ]);
-__publicField(SimpleStepViewer, "monikers", [StepViewerMoniker2]);
-__publicField(SimpleStepViewer, "surface", "node");
-SimpleStepViewer = __decorateClass([
-  creatableProvider14()
-], SimpleStepViewer);
+__publicField(SimpleXyoViewer, "monikers", [XyoViewerMoniker3]);
+__publicField(SimpleXyoViewer, "surface", "node");
+SimpleXyoViewer = __decorateClass([
+  creatableProvider12()
+], SimpleXyoViewer);
 
 // src/locators/providerCandidates.ts
 var PROVIDER_IMPLEMENTATIONS = [
@@ -1482,10 +1393,6 @@ var PROVIDER_IMPLEMENTATIONS = [
   JsonRpcXyoRunner,
   JsonRpcXyoSigner,
   JsonRpcXyoViewer,
-  // eslint-disable-next-line @typescript-eslint/no-deprecated -- backward-compat provider registry
-  NodeXyoRunner,
-  // eslint-disable-next-line @typescript-eslint/no-deprecated -- backward-compat provider registry
-  NodeXyoViewer,
   RestDataLakeRunner,
   RestDataLakeViewer,
   SimpleAccountBalanceViewer,
@@ -1497,7 +1404,7 @@ var PROVIDER_IMPLEMENTATIONS = [
   SimpleDeadLetterQueueViewer,
   SimpleFinalizationRunner,
   SimpleFinalizationViewer,
-  SimpleMempoolRunner2,
+  SimpleMempoolRunner,
   SimpleMempoolViewer,
   SimpleNetworkStakeViewer,
   SimpleStakeEventsViewer,
@@ -1656,24 +1563,13 @@ async function basicRemoteRunnerLocator(name, rpcConnection, signerTransport, da
   return locator;
 }
 
-// src/locators/commonLocatorFromConfig.ts
-import { ProviderFactoryLocator as ProviderFactoryLocator5 } from "@xyo-network/xl1-protocol-sdk";
-function commonLocatorFromConfig(context, validateDepsOnRegister = false) {
-  return new ProviderFactoryLocator5(context, {}, validateDepsOnRegister);
-}
-
-// src/locators/commonProvidersFromConfig.ts
-function commonProvidersFromConfig() {
-  return [];
-}
-
 // src/locators/rootLocatorFromConfig.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk";
+import { assertEx as assertEx5 } from "@ariestools/sdk";
 async function rootLocatorFromConfig(context, validateDepsOnRegister = false, validators) {
   const { config } = context;
   const hasRpcConnection = config.connections?.["default-rpc"] !== void 0 || Object.values(config.connections ?? {}).some((connection) => connection?.type === "rpc");
   const newLocator = hasRpcConnection ? await remoteLocatorFromConfig(context, validateDepsOnRegister, validators) : void 0;
-  const locator = assertEx7(newLocator, () => "Root locator could not be created from config. No supported configuration found.");
+  const locator = assertEx5(newLocator, () => "Root locator could not be created from config. No supported configuration found.");
   locator.freeze();
   return locator;
 }
@@ -1702,16 +1598,6 @@ import {
   SimpleXyoGatewayRunner as SimpleXyoGatewayRunner3,
   SimpleXyoSigner as SimpleXyoSigner2
 } from "@xyo-network/xl1-protocol-sdk";
-var registerGatewayRunnerWithLocatorIfProvided = (locator, params) => {
-  const account = params?.signerAccount;
-  if (account) {
-    locator.registerMany([
-      SimpleXyoSigner2.factory(SimpleXyoSigner2.dependencies, { account }),
-      SimpleXyoGatewayRunner3.factory(SimpleXyoGatewayRunner3.dependencies, {})
-    ]);
-  }
-  return locator;
-};
 var registerGatewayWithLocator = (locator, account) => {
   locator.registerMany([
     SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
@@ -1733,8 +1619,6 @@ var registerSimpleStakeViewerWithLocator = (locator, positions) => {
   return locator;
 };
 export {
-  NodeXyoRunner,
-  NodeXyoViewer,
   SimpleDeadLetterQueueRunner,
   SimpleDeadLetterQueueViewer,
   SimpleNetworkStakeViewer,
@@ -1751,13 +1635,11 @@ export {
   baseConfigFactoryLocator,
   basicRemoteRunnerLocator,
   basicRemoteViewerLocator,
+  buildSimpleXyoSigner,
   buildSimpleXyoSignerV2,
-  commonLocatorFromConfig,
-  commonProvidersFromConfig,
   createRestDataLakeRunner,
   createRestDataLakeViewer,
   locatorFromAdaptedConfig,
-  registerGatewayRunnerWithLocatorIfProvided,
   registerGatewayWithLocator,
   registerSimpleStakeViewerWithLocator,
   remoteLocatorFromConfig,