@xyo-network/xl1-providers 1.18.0-rc.1

package/src/SimpleStepRewardsByStakerViewer.ts

@@ -0,0 +1,102 @@
+import type { Address, Promisable } from '@xylabs/sdk-js'
+import { isArray } from '@xylabs/sdk-js'
+import type {
+  AttoXL1,
+  XL1RangeMultipliers,
+} from '@xyo-network/xl1-protocol'
+import { asAttoXL1, asXL1BlockRange } from '@xyo-network/xl1-protocol'
+import {
+  AbstractCreatableProvider,
+  blockRangeSteps,
+  BlockViewer,
+  BlockViewerMoniker,
+  creatableProvider,
+  CreatableProviderParams,
+  type NetworkStakeStepRewardsByStakerViewer, NetworkStakeStepRewardsByStakerViewerMoniker,
+  type NetworkStakeStepRewardsByStakerViewerOptions, type StakedChainContextRead,
+} from '@xyo-network/xl1-protocol-sdk'
+
+import { networkStakeStepRewardEarnedForStaker } from './primitives/index.ts'
+
+export interface SimpleStepRewardsByStakerViewerParams extends CreatableProviderParams {
+  rewardMultipliers?: XL1RangeMultipliers
+  stakedChainContext: StakedChainContextRead
+}
+
+@creatableProvider()
+export class SimpleStepRewardsByStakerViewer extends
+  AbstractCreatableProvider<SimpleStepRewardsByStakerViewerParams> implements NetworkStakeStepRewardsByStakerViewer {
+  static readonly defaultMoniker = NetworkStakeStepRewardsByStakerViewerMoniker
+  static readonly monikers = [NetworkStakeStepRewardsByStakerViewerMoniker]
+  moniker = SimpleStepRewardsByStakerViewer.defaultMoniker
+
+  private _blockViewer?: BlockViewer
+
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {}
+  }
+
+  get stakedChainContext() {
+    return this.params.stakedChainContext
+  }
+
+  protected get blockViewer() {
+    return this._blockViewer!
+  }
+
+  async bonus({ range, stakers }: NetworkStakeStepRewardsByStakerViewerOptions = {}): Promise<Record<Address, AttoXL1>> {
+    const total = await this.total({ range, stakers })
+    const earned = await this.earned({ range, stakers })
+    const result: Record<Address, AttoXL1> = {}
+    for (const staker of Object.keys(total) as Address[]) {
+      result[staker] = asAttoXL1(total[staker] - (earned[staker] ?? 0n))
+    }
+    return result
+  }
+
+  claimed(_options?: NetworkStakeStepRewardsByStakerViewerOptions | undefined): Promisable<Record<Address, AttoXL1>> {
+    throw new Error('Method [claimed] not implemented.')
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker)
+  }
+
+  async earned(options: NetworkStakeStepRewardsByStakerViewerOptions = {}): Promise<Record<Address, AttoXL1>> {
+    return await this.calculateRewards(options)
+  }
+
+  async total(options: NetworkStakeStepRewardsByStakerViewerOptions = {}): Promise<Record<Address, AttoXL1>> {
+    return await this.calculateRewards(options, this.rewardMultipliers)
+  }
+
+  unclaimed(_options: NetworkStakeStepRewardsByStakerViewerOptions = {}): Promisable<Record<Address, AttoXL1>> {
+    throw new Error('Method [unclaimed] not implemented.')
+  }
+
+  protected async calculateRewards(
+    { range, stakers }: NetworkStakeStepRewardsByStakerViewerOptions = {},
+    rewardMultipliers?: XL1RangeMultipliers,
+  ): Promise<Record<Address, AttoXL1>> {
+    const result: Record<Address, AttoXL1> = {}
+    const steps = blockRangeSteps(asXL1BlockRange(
+      range ?? [0, (await this.stakedChainContext.head())[1]],
+      { name: 'NodeStepRewardsByStakerViewer' },
+    ), [3, 4, 5, 6, 7])
+    for (const step of steps) {
+      if (isArray(stakers)) {
+        for (const staker of stakers) {
+          result[staker] = asAttoXL1((result[staker] ?? 0n) + (await networkStakeStepRewardEarnedForStaker(
+            this.stakedChainContext,
+            this.blockViewer,
+            step,
+            staker,
+            rewardMultipliers,
+          ))[0])
+        }
+      }
+    }
+    return result
+  }
+}

package/src/SimpleStepRewardsByStepViewer.ts

@@ -0,0 +1,110 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type {
+  AttoXL1,
+  StepIdentityString,
+  XL1RangeMultipliers,
+} from '@xyo-network/xl1-protocol'
+import { asAttoXL1, asXL1BlockRange } from '@xyo-network/xl1-protocol'
+import type {
+  BlockViewer,
+  CreatableProviderParams,
+  NetworkStakeStepRewardsByStepViewer,
+  NetworkStakeStepRewardsByStepViewerOptions,
+  StakedChainContextRead,
+  StakeEventsViewer,
+} from '@xyo-network/xl1-protocol-sdk'
+import {
+  AbstractCreatableProvider,
+  blockRangeSteps,
+  BlockViewerMoniker,
+  creatableProvider, NetworkStakeStepRewardsByStepViewerMoniker, toStepIdentityString,
+} from '@xyo-network/xl1-protocol-sdk'
+
+import { networkStakeStepRewardEarned } from './primitives/index.ts'
+
+export interface SimpleStepRewardsByStepViewerParams extends CreatableProviderParams {
+  rewardMultipliers?: XL1RangeMultipliers
+  stakeEventsViewer: StakeEventsViewer
+  stakedChainContext: StakedChainContextRead
+}
+
+@creatableProvider()
+export class SimpleStepRewardsByStepViewer extends
+  AbstractCreatableProvider<SimpleStepRewardsByStepViewerParams> implements NetworkStakeStepRewardsByStepViewer {
+  static readonly defaultMoniker = NetworkStakeStepRewardsByStepViewerMoniker
+  static readonly monikers = [NetworkStakeStepRewardsByStepViewerMoniker]
+  moniker = SimpleStepRewardsByStepViewer.defaultMoniker
+
+  private _blockViewer?: BlockViewer
+
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {}
+  }
+
+  get stakedChainContext() {
+    return this.params.stakedChainContext
+  }
+
+  protected get blockViewer() {
+    return this._blockViewer!
+  }
+
+  async bonus({ range, steps }: NetworkStakeStepRewardsByStepViewerOptions = {}): Promise<Record<StepIdentityString, AttoXL1>> {
+    const total = await this.total({ range, steps })
+    const earned = await this.earned({ range, steps })
+    const result: Record<StepIdentityString, AttoXL1> = {}
+    for (const stepString of Object.keys(total) as StepIdentityString[]) {
+      result[stepString] = asAttoXL1(total[stepString] - (earned[stepString] ?? 0n))
+    }
+    return result
+  }
+
+  claimed(_options?: NetworkStakeStepRewardsByStepViewerOptions | undefined): Promisable<Record<StepIdentityString, AttoXL1>> {
+    throw new Error('Method [claimed] not implemented.')
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker)
+  }
+
+  async earned({ range, steps }: NetworkStakeStepRewardsByStepViewerOptions = {}): Promise<Record<StepIdentityString, AttoXL1>> {
+    const result: Record<StepIdentityString, AttoXL1> = {}
+    const resolvedSteps = steps ?? blockRangeSteps(asXL1BlockRange(
+      range ?? [0, (await this.stakedChainContext.head())[1]],
+      { name: 'NodeStepRewardsByStepViewer' },
+    ), [3, 4, 5, 6, 7])
+    for (const step of resolvedSteps) {
+      const stepIdentityString = toStepIdentityString(step)
+      result[stepIdentityString] = asAttoXL1((result[stepIdentityString] ?? 0n) + (await networkStakeStepRewardEarned(
+        this.stakedChainContext,
+        this.blockViewer,
+        step,
+      ))[0])
+    }
+    return result
+  }
+
+  async total({ range, steps }: NetworkStakeStepRewardsByStepViewerOptions = {}): Promise<Record<StepIdentityString, AttoXL1>> {
+    const result: Record<StepIdentityString, AttoXL1> = {}
+    const resolvedSteps = steps ?? blockRangeSteps(asXL1BlockRange(
+      range ?? [0, (await this.stakedChainContext.head())[1]],
+      { name: 'NodeStepRewardsByStepViewer' },
+    ), [3, 4, 5, 6, 7])
+    for (const step of resolvedSteps) {
+      const stepIdentityString = toStepIdentityString(step)
+      result[stepIdentityString] = asAttoXL1((result[stepIdentityString] ?? 0n)
+        + (await networkStakeStepRewardEarned(
+          this.stakedChainContext,
+          this.blockViewer,
+          step,
+          this.rewardMultipliers,
+        ))[0])
+    }
+    return result
+  }
+
+  unclaimed(_options: NetworkStakeStepRewardsByStepViewerOptions = {}): Promisable<Record<StepIdentityString, AttoXL1>> {
+    throw new Error('Method  [unclaimed] ot implemented.')
+  }
+}

package/src/SimpleStepRewardsTotalViewer.ts

@@ -0,0 +1,63 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type {
+  AttoXL1,
+  XL1RangeMultipliers,
+} from '@xyo-network/xl1-protocol'
+import { asAttoXL1 } from '@xyo-network/xl1-protocol'
+import {
+  AbstractCreatableProvider,
+  creatableProvider,
+  CreatableProviderParams,
+  type NetworkStakeStepRewardsRangeOptions, type NetworkStakeStepRewardsTotalViewer, NetworkStakeStepRewardsTotalViewerMoniker,
+  type StakedChainContextRead,
+} from '@xyo-network/xl1-protocol-sdk'
+
+export interface SimpleStepRewardsTotalViewerParams extends CreatableProviderParams {
+  rewardMultipliers?: XL1RangeMultipliers
+  stakedChainContext: StakedChainContextRead
+}
+
+@creatableProvider()
+export class SimpleStepRewardsTotalViewer extends
+  AbstractCreatableProvider<SimpleStepRewardsTotalViewerParams> implements NetworkStakeStepRewardsTotalViewer {
+  static readonly defaultMoniker = NetworkStakeStepRewardsTotalViewerMoniker
+  static readonly monikers = [NetworkStakeStepRewardsTotalViewerMoniker]
+  moniker = SimpleStepRewardsTotalViewer.defaultMoniker
+
+  get rewardMultipliers() {
+    return this.params.rewardMultipliers ?? {}
+  }
+
+  get stakedChainContext() {
+    return this.params.stakedChainContext
+  }
+
+  async bonus({ range }: NetworkStakeStepRewardsRangeOptions = {}): Promise<AttoXL1> {
+    const total = await this.total({ range })
+    const earned = await this.earned({ range })
+    return asAttoXL1(total - earned)
+  }
+
+  claimed(_options?: NetworkStakeStepRewardsRangeOptions | undefined): Promisable<AttoXL1> {
+    throw new Error('Method [claimed] not implemented.')
+  }
+
+  async earned(options: NetworkStakeStepRewardsRangeOptions = {}): Promise<AttoXL1> {
+    return await this.calculateRewards(options)
+  }
+
+  async total(options: NetworkStakeStepRewardsRangeOptions = {}): Promise<AttoXL1> {
+    return await this.calculateRewards(options, this.rewardMultipliers)
+  }
+
+  unclaimed(_options: NetworkStakeStepRewardsRangeOptions = {}): Promisable<AttoXL1> {
+    throw new Error('Method [unclaimed] not implemented.')
+  }
+
+  protected calculateRewards(
+    _options: NetworkStakeStepRewardsRangeOptions = {},
+    _rewardMultipliers?: XL1RangeMultipliers,
+  ): Promise<AttoXL1> {
+    throw new Error('Method  [calculateRewards] not implemented.')
+  }
+}

package/src/SimpleStepRewardsViewer.ts

@@ -0,0 +1,75 @@
+import { assertEx } from '@xylabs/sdk-js'
+import type { XL1RangeMultipliers } from '@xyo-network/xl1-protocol'
+import {
+  AbstractCreatableProvider,
+  BlockViewer,
+  BlockViewerMoniker,
+  creatableProvider,
+  CreatableProviderParams,
+  type NetworkStakeStepRewardsByPositionViewer, NetworkStakeStepRewardsByPositionViewerMoniker,
+  type NetworkStakeStepRewardsByStakerViewer, NetworkStakeStepRewardsByStakerViewerMoniker, type NetworkStakeStepRewardsByStepViewer,
+  NetworkStakeStepRewardsByStepViewerMoniker,
+  type NetworkStakeStepRewardsTotalViewer, type NetworkStakeStepRewardsViewer,
+  NetworkStakeStepRewardsViewerMoniker,
+  type StakedChainContextRead,
+} from '@xyo-network/xl1-protocol-sdk'
+
+import { SimpleStepRewardsByPositionViewer } from './SimpleStepRewardsByPositionViewer.ts'
+import { SimpleStepRewardsByStakerViewer } from './SimpleStepRewardsByStakerViewer.ts'
+import { SimpleStepRewardsByStepViewer } from './SimpleStepRewardsByStepViewer.ts'
+
+export interface NodeStepRewardsViewerParams extends CreatableProviderParams {
+  rewardMultipliers?: XL1RangeMultipliers
+}
+
+@creatableProvider()
+export class SimpleStepRewardsViewer extends AbstractCreatableProvider<NodeStepRewardsViewerParams> implements NetworkStakeStepRewardsViewer {
+  static readonly defaultMoniker = NetworkStakeStepRewardsViewerMoniker
+  static readonly monikers = [NetworkStakeStepRewardsViewerMoniker]
+  moniker = SimpleStepRewardsViewer.defaultMoniker
+
+  private _blockViewer?: BlockViewer
+  private _position?: SimpleStepRewardsByPositionViewer
+  private _stakedChainContext?: StakedChainContextRead
+  private _staker?: SimpleStepRewardsByStakerViewer
+  private _step?: SimpleStepRewardsByStepViewer
+
+  get position(): NetworkStakeStepRewardsByPositionViewer {
+    return assertEx(this._position, () => 'Position viewer not initialized')
+  }
+
+  get staker(): NetworkStakeStepRewardsByStakerViewer {
+    return assertEx(this._staker, () => 'Position viewer not initialized')
+  }
+
+  get step(): NetworkStakeStepRewardsByStepViewer {
+    return assertEx(this._step, () => 'Step viewer not initialized')
+  }
+
+  get total(): NetworkStakeStepRewardsTotalViewer {
+    throw new Error('Method [total] not implemented.')
+  }
+
+  protected get rewardMultipliers() {
+    return this.params.rewardMultipliers
+  }
+
+  protected get stakedChainContext() {
+    return this._stakedChainContext
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
+    this._position = await this.locator.getInstance<SimpleStepRewardsByPositionViewer>(NetworkStakeStepRewardsByPositionViewerMoniker)
+    this._staker = await this.locator.getInstance<SimpleStepRewardsByStakerViewer>(NetworkStakeStepRewardsByStakerViewerMoniker)
+    this._step = await this.locator.getInstance<SimpleStepRewardsByStepViewer>(NetworkStakeStepRewardsByStepViewerMoniker)
+  }
+
+  protected override async startHandler(): Promise<void> {
+    await super.startHandler()
+    await assertEx(this._position, () => 'Position viewer not created').start()
+    await assertEx(this._staker, () => 'Staker viewer not created').start()
+    await assertEx(this._step, () => 'Step viewer not created').start()
+  }
+}

package/src/SimpleStepViewer.ts

@@ -0,0 +1,98 @@
+import {
+  type Address,
+  type Promisable,
+} from '@xylabs/sdk-js'
+import type { PositionId, StepIdentity } from '@xyo-network/xl1-protocol'
+import {
+  AbstractCreatableProvider,
+  BlockViewer,
+  BlockViewerMoniker,
+  creatableProvider,
+  CreatableProviderParams,
+  externalBlockRangeFromStep,
+  NetworkStakeStepRewardsViewer,
+  NetworkStakeStepRewardsViewerMoniker,
+  type PagedPositionsOptions,
+  type PagedStakersOptions,
+  type Position,
+  StakeEventsViewer,
+  StakeEventsViewerMoniker,
+  StakeViewer,
+  StakeViewerMoniker,
+  type StepViewer,
+  StepViewerMoniker,
+} from '@xyo-network/xl1-protocol-sdk'
+
+export interface SimpleStepViewerParams extends CreatableProviderParams {
+
+}
+
+@creatableProvider()
+export class SimpleStepViewer extends AbstractCreatableProvider<SimpleStepViewerParams> implements StepViewer {
+  static readonly defaultMoniker = StepViewerMoniker
+  static readonly monikers = [StepViewerMoniker]
+  moniker = SimpleStepViewer.defaultMoniker
+
+  private _blockViewer?: BlockViewer
+  private _networkStakeStepRewardsViewer?: NetworkStakeStepRewardsViewer
+  private _stakeEventsViewer?: StakeEventsViewer
+  private _stakeViewer?: StakeViewer
+
+  get rewards() {
+    return this._networkStakeStepRewardsViewer!
+  }
+
+  protected get blockViewer() {
+    return this._blockViewer!
+  }
+
+  protected get stakeEventsViewer() {
+    return this._stakeEventsViewer!
+  }
+
+  protected get stakeViewer() {
+    return this._stakeViewer!
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
+    this._networkStakeStepRewardsViewer = await this.locator.getInstance<NetworkStakeStepRewardsViewer>(NetworkStakeStepRewardsViewerMoniker)
+    this._stakeViewer = await this.locator.getInstance<StakeViewer>(StakeViewerMoniker)
+    this._stakeEventsViewer = await this.locator.getInstance<StakeEventsViewer>(StakeEventsViewerMoniker)
+  }
+
+  async positionCount(step: StepIdentity): Promise<number> {
+    const externalRange = await externalBlockRangeFromStep(this.context, this.blockViewer, step)
+    const positionCount = await this.stakeEventsViewer.positionCount(externalRange)
+    return positionCount
+  }
+
+  // TODO: Implement paging
+  async positions(step: StepIdentity, _options?: PagedPositionsOptions): Promise<Position[]> {
+    const count = await this.positionCount(step)
+    const externalRange = await externalBlockRangeFromStep(this.context, this.blockViewer, step)
+    const allPositions = await Promise.all(Array.from({ length: count + 1 }, (_, i) => i).map(id => this.stakeViewer.stakeById(id)))
+    return allPositions.filter(pos => pos.addBlock <= externalRange[1] && (pos.removeBlock === 0 || pos.removeBlock > externalRange[0]))
+  }
+
+  randomizer(_step: StepIdentity): Promisable<bigint> {
+    throw new Error('Method [randomizer] not implemented.')
+  }
+
+  stake(_step: StepIdentity): Promisable<bigint> {
+    throw new Error('Method [stake] not implemented.')
+  }
+
+  stakerCount(_step: StepIdentity): Promisable<number> {
+    throw new Error('Method [stakerCount] not implemented.')
+  }
+
+  stakers(_step: StepIdentity, _options?: PagedStakersOptions): Promisable<Address[]> {
+    throw new Error('Method [stakers] not implemented.')
+  }
+
+  weight(_step: StepIdentity, _positionId?: PositionId): Promisable<bigint> {
+    throw new Error('Method [weight] not implemented.')
+  }
+}

package/src/SimpleXyoConnection.ts

@@ -0,0 +1,52 @@
+import { CreatableParams } from '@xylabs/sdk-js'
+import {
+  AbstractCreatableProvider,
+  creatableProvider,
+  type CreatableProviderContext,
+  type DataLakeRunner, DataLakeRunnerMoniker, type DataLakeViewer, DataLakeViewerMoniker,
+  type XyoConnection, XyoConnectionMoniker, type XyoNetwork, type XyoRunner, XyoRunnerMoniker,
+  type XyoViewer,
+  XyoViewerMoniker,
+} from '@xyo-network/xl1-protocol-sdk'
+
+export interface SimpleXyoConnectionParams<TContext extends CreatableProviderContext = CreatableProviderContext> extends CreatableParams {
+  context: TContext
+}
+
+@creatableProvider()
+export class SimpleXyoConnection<TParams extends SimpleXyoConnectionParams = SimpleXyoConnectionParams> extends
+  AbstractCreatableProvider<TParams> implements XyoConnection {
+  static readonly defaultMoniker = XyoConnectionMoniker
+  static readonly monikers = [XyoConnectionMoniker]
+  moniker = SimpleXyoConnection.defaultMoniker
+
+  protected _network?: XyoNetwork
+  protected _runner?: XyoRunner
+  protected _storage?: DataLakeRunner | DataLakeViewer
+  protected _viewer?: XyoViewer
+
+  get network(): XyoNetwork | undefined {
+    return this._network
+  }
+
+  get runner(): XyoRunner | undefined {
+    return this._runner
+  }
+
+  get storage(): DataLakeRunner | DataLakeViewer | undefined {
+    return this._storage
+  }
+
+  get viewer(): XyoViewer | undefined {
+    return this._viewer
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._runner = await this.locator.getInstance<XyoRunner>(XyoRunnerMoniker)
+    this._viewer = await this.locator.getInstance<XyoViewer>(XyoViewerMoniker)
+    const dataLakeRunner = await this.locator.tryGetInstance<DataLakeRunner>(DataLakeRunnerMoniker)
+    const dataLakeViewer = await this.locator.tryGetInstance<DataLakeViewer>(DataLakeViewerMoniker)
+    this._storage = dataLakeRunner ?? dataLakeViewer
+  }
+}

package/src/buildProviderLocator.ts

@@ -0,0 +1,137 @@
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { NodeInstance } from '@xyo-network/node-model'
+import type {
+  BalanceStepSummaryContext,
+  CreatableProviderContext, TransfersStepSummaryContext,
+} from '@xyo-network/xl1-protocol-sdk'
+import {
+  getDefaultConfig, ProviderFactoryLocator, SimpleAccountBalanceViewer, SimpleBlockViewer,
+  SimpleMempoolRunner, SimpleMempoolViewer, SimpleStakeEventsViewer,
+  SimpleStakeViewer,
+  SimpleTimeSyncViewer,
+  SimpleXyoRunner,
+} from '@xyo-network/xl1-protocol-sdk'
+import type { TransportFactory } from '@xyo-network/xl1-rpc'
+import {
+  AccountBalanceViewerRpcSchemas,
+  BlockViewerRpcSchemas,
+  DataLakeViewerRpcSchemas,
+  JsonRpcAccountBalanceViewer, JsonRpcBlockViewer, JsonRpcDataLakeViewer, JsonRpcMempoolRunner, JsonRpcMempoolViewer,
+  JsonRpcNetworkStakeViewer, JsonRpcNetworkStakingStepRewardsViewer, JsonRpcStakeTotalsViewer,
+  JsonRpcTimeSyncViewer,
+  JsonRpcXyoRunner,
+  JsonRpcXyoViewer,
+  MempoolRunnerRpcSchemas,
+  MempoolViewerRpcSchemas,
+  NetworkStakeViewerRpcSchemas,
+  StakeTotalsViewerRpcSchemas,
+  TimeSyncViewerRpcSchemas,
+  XyoRunnerRpcSchemas,
+  XyoViewerRpcSchemas,
+} from '@xyo-network/xl1-rpc'
+
+import { NodeXyoViewer } from './NodeXyoViewer.ts'
+import { SimpleNetworkStakeViewer } from './SimpleNetworkStakeViewer.ts'
+import { SimpleStepRewardsByPositionViewer } from './SimpleStepRewardsByPositionViewer.ts'
+import { SimpleStepRewardsByStakerViewer } from './SimpleStepRewardsByStakerViewer.ts'
+import { SimpleStepRewardsByStepViewer } from './SimpleStepRewardsByStepViewer.ts'
+import { SimpleStepRewardsTotalViewer } from './SimpleStepRewardsTotalViewer.ts'
+import { SimpleStepRewardsViewer } from './SimpleStepRewardsViewer.ts'
+import { SimpleStepViewer } from './SimpleStepViewer.ts'
+import { SimpleXyoConnection } from './SimpleXyoConnection.ts'
+
+export interface BuildProviderLocatorParams {
+  context?: Partial<CreatableProviderContext>
+}
+
+export function buildProviderLocator({ context = {} }: BuildProviderLocatorParams = {}) {
+  const {
+    config = getDefaultConfig(), locator, singletons = {}, ...restOfContext
+  } = context
+  return new ProviderFactoryLocator({
+    ...restOfContext, config, singletons,
+  }, locator?.registry)
+}
+
+export interface BuildSimpleProviderLocatorParams extends BuildProviderLocatorParams {
+
+}
+
+export function buildSimpleProviderLocator(params: BuildSimpleProviderLocatorParams = {}) {
+  const locator = buildProviderLocator(params)
+  return locator.registerMany([
+    SimpleStakeViewer.factory<SimpleStakeViewer>(),
+    SimpleStakeEventsViewer.factory<SimpleStakeEventsViewer>(),
+    SimpleNetworkStakeViewer.factory<SimpleNetworkStakeViewer>(),
+    SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(),
+    SimpleStepViewer.factory<SimpleStepViewer>(),
+    SimpleStepRewardsViewer.factory<SimpleStepRewardsViewer>(),
+    SimpleStepRewardsByPositionViewer.factory<SimpleStepRewardsByPositionViewer>(),
+    SimpleStepRewardsByStakerViewer.factory<SimpleStepRewardsByStakerViewer>(),
+    SimpleStepRewardsByStepViewer.factory<SimpleStepRewardsByStepViewer>(),
+    SimpleStepRewardsTotalViewer.factory<SimpleStepRewardsTotalViewer>(),
+    SimpleStakeViewer.factory<SimpleStakeViewer>(),
+    SimpleXyoConnection.factory<SimpleXyoConnection>(),
+  ])
+}
+
+export interface BuildJsonRpcProviderLocatorParams extends BuildProviderLocatorParams {
+  transportFactory: TransportFactory
+}
+
+export async function buildJsonRpcProviderLocator(params: BuildJsonRpcProviderLocatorParams) {
+  const locator = buildProviderLocator(params)
+  const transportFactory = params.transportFactory
+  return locator.registerMany([
+    JsonRpcStakeTotalsViewer.factory<JsonRpcStakeTotalsViewer>({ transport: await transportFactory(StakeTotalsViewerRpcSchemas) }),
+    JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>({ transport: await transportFactory(AccountBalanceViewerRpcSchemas) }),
+    JsonRpcBlockViewer.factory<JsonRpcBlockViewer>({ transport: await transportFactory(BlockViewerRpcSchemas) }),
+    JsonRpcDataLakeViewer.factory<JsonRpcDataLakeViewer>({ transport: await transportFactory(DataLakeViewerRpcSchemas) }),
+    JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>({ transport: await transportFactory(MempoolRunnerRpcSchemas) }),
+    JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>({ transport: await transportFactory(MempoolViewerRpcSchemas) }),
+    JsonRpcNetworkStakeViewer.factory<JsonRpcNetworkStakeViewer>({ transport: await transportFactory(NetworkStakeViewerRpcSchemas) }),
+    JsonRpcTimeSyncViewer.factory<JsonRpcTimeSyncViewer>({ transport: await transportFactory(TimeSyncViewerRpcSchemas) }),
+    JsonRpcNetworkStakingStepRewardsViewer.factory<JsonRpcNetworkStakingStepRewardsViewer>({ transport: await transportFactory(NetworkStakeViewerRpcSchemas) }),
+    JsonRpcXyoRunner.factory<JsonRpcXyoRunner>({ transport: await transportFactory(XyoRunnerRpcSchemas) }),
+    JsonRpcXyoViewer.factory<JsonRpcXyoViewer>({ transport: await transportFactory(XyoViewerRpcSchemas) }),
+    SimpleStakeViewer.factory<SimpleStakeViewer>(),
+    SimpleStakeEventsViewer.factory<SimpleStakeEventsViewer>(),
+    SimpleStepViewer.factory<SimpleStepViewer>(),
+    SimpleXyoConnection.factory<SimpleXyoConnection>(),
+  ])
+}
+
+export interface BuildLocalProviderLocatorParams extends BuildProviderLocatorParams {
+  balanceSummaryContext: BalanceStepSummaryContext
+  finalizedArchivist: ArchivistInstance
+  node: NodeInstance
+  pendingBlocksArchivist: ArchivistInstance
+  pendingTransactionsArchivist: ArchivistInstance
+  transfersSummaryContext: TransfersStepSummaryContext
+}
+
+export function buildLocalProviderLocator({
+  balanceSummaryContext, finalizedArchivist, pendingBlocksArchivist,
+  pendingTransactionsArchivist,
+  transfersSummaryContext, node,
+  ...params
+}: BuildLocalProviderLocatorParams) {
+  const locator = buildSimpleProviderLocator(params)
+  return locator.registerMany([
+    SimpleMempoolViewer.factory<SimpleMempoolViewer>({
+      pendingTransactionsArchivist,
+      pendingBlocksArchivist,
+    }),
+    SimpleMempoolRunner.factory<SimpleMempoolRunner>({
+      pendingTransactionsArchivist,
+      pendingBlocksArchivist,
+    }),
+    SimpleAccountBalanceViewer.factory<SimpleAccountBalanceViewer>({
+      balanceSummaryContext,
+      transfersSummaryContext,
+    }),
+    SimpleBlockViewer.factory<SimpleBlockViewer>({ finalizedArchivist }),
+    SimpleXyoRunner.factory<SimpleXyoRunner>({ pendingTransactionsArchivist }),
+    NodeXyoViewer.factory<NodeXyoViewer>({ node }),
+  ])
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './buildProviderLocator.ts'
+export * from './NodeXyoViewer.ts'
+export * from './SimpleNetworkStakeViewer.ts'
+export * from './SimpleStepRewardsByPositionViewer.ts'
+export * from './SimpleStepRewardsByStakerViewer.ts'
+export * from './SimpleStepRewardsByStepViewer.ts'
+export * from './SimpleStepRewardsTotalViewer.ts'
+export * from './SimpleStepRewardsViewer.ts'
+export * from './SimpleStepViewer.ts'
+export * from './SimpleXyoConnection.ts'

package/src/primitives/index.ts

@@ -0,0 +1,3 @@
+export * from './networkStakeStepRewardEarned.ts'
+export * from './networkStakeStepRewardEarnedForPosition.ts'
+export * from './networkStakeStepRewardEarnedForStaker.ts'