@xyo-network/xl1-providers 1.26.12 → 1.26.13

package/src/SimpleXyoViewer.ts

@@ -1,473 +0,0 @@
-import type { Tracer } from '@opentelemetry/api'
-import type {
-  Address,
-  Hash, Promisable,
-} from '@xylabs/sdk-js'
-import {
-  assertEx,
-  toAddress,
-} from '@xylabs/sdk-js'
-import type { Payload, WithHashMeta } from '@xyo-network/sdk-js'
-import type {
-  AccountBalanceViewer,
-  AttoXL1,
-  BlockRate,
-  BlockViewer, ChainContractViewer, ChainId,
-  ChainQualifiedConfig, Count,
-  FinalizationViewer,
-  ForkHistory,
-  MempoolViewer, NetworkStakeStepRewardsByPositionViewer, NetworkStakeViewer, Position,
-  SingleTimeConfig,
-  StakeViewer,
-  StepIdentity, StepIdentityString,
-  StepIndex,
-  StepViewer,
-  TimeDurations,
-  TimeSyncViewer,
-  TransactionViewer,
-  XL1BlockNumber, XL1BlockRange, XL1RangeMultipliers,
-  XyoViewer,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  AccountBalanceViewerMoniker,
-  asAttoXL1,
-  asXL1BlockRange,
-  BlockViewerMoniker,
-  ChainContractViewerMoniker,
-  FinalizationViewerMoniker,
-  MempoolViewerMoniker, NetworkStakeStepRewardsByPositionViewerMoniker,
-  NetworkStakeViewerMoniker, StakeViewerMoniker, StepViewerMoniker, TimeSyncViewerMoniker, TransactionViewerMoniker, XYO_NETWORK_STAKING_ADDRESS,
-  XYO_ZERO_ADDRESS,
-  XyoViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  AbstractCreatableProvider,
-  allStakersForStep,
-  blockRangeSteps,
-  creatableProvider,
-  CreatableProviderParams,
-  externalBlockRangeFromStep,
-  externalBlockRangeFromXL1BlockRange,
-  networkStakeStepRewardPositionWeight,
-  stepRewardTotal,
-  toStepIdentityString,
-  weightedStakeForRangeByPosition,
-  withContextCacheResponse,
-} from '@xyo-network/xl1-protocol-sdk'
-
-/** Configuration params for SimpleXyoViewer. */
-export interface SimpleXyoViewerParams extends CreatableProviderParams {
-  initRewardsCache?: boolean
-  rewardMultipliers?: XL1RangeMultipliers
-}
-
-/** Full-featured XYO viewer providing access to blocks, transactions, staking, rewards, and account balances. */
-@creatableProvider()
-export class SimpleXyoViewer<TParams extends SimpleXyoViewerParams = SimpleXyoViewerParams> extends AbstractCreatableProvider<TParams> implements XyoViewer {
-  static readonly defaultMoniker = XyoViewerMoniker
-
-  static readonly dependencies = [
-    AccountBalanceViewerMoniker,
-    BlockViewerMoniker,
-    FinalizationViewerMoniker,
-    MempoolViewerMoniker,
-    NetworkStakeViewerMoniker,
-    NetworkStakeStepRewardsByPositionViewerMoniker,
-    StakeViewerMoniker,
-    StepViewerMoniker,
-    TimeSyncViewerMoniker,
-  ]
-
-  static readonly monikers = [XyoViewerMoniker]
-  moniker = SimpleXyoViewer.defaultMoniker
-
-  protected _tracer: Tracer | undefined
-
-  private _accountBalanceViewer?: AccountBalanceViewer
-  private _blockViewer?: BlockViewer
-  private _chainContractViewer?: ChainContractViewer
-  private _chainId!: ChainId
-  private _finalizationViewer!: FinalizationViewer
-  private _mempoolViewer?: MempoolViewer
-  private _networkStakeViewer?: NetworkStakeViewer
-  private _networkStepRewardsByPositionViewer?: NetworkStakeStepRewardsByPositionViewer
-  private _rewardMultipliers?: XL1RangeMultipliers
-  private _stakeViewer?: StakeViewer
-  private _stepViewer?: StepViewer
-  private _timeSyncViewer?: TimeSyncViewer
-  private _transaction?: TransactionViewer
-
-  get account() {
-    return { balance: this._accountBalanceViewer! }
-  }
-
-  get block() {
-    return this._blockViewer!
-  }
-
-  get chainContractViewer() {
-    return this._chainContractViewer!
-  }
-
-  get finalization() {
-    return this._finalizationViewer!
-  }
-
-  get mempool() {
-    return this._mempoolViewer!
-  }
-
-  get networkStake() {
-    return this._networkStakeViewer!
-  }
-
-  get stake() {
-    return this._stakeViewer!
-  }
-
-  get step() {
-    return this._stepViewer!
-  }
-
-  get time() {
-    return this._timeSyncViewer!
-  }
-
-  get transaction() {
-    return this._transaction!
-  }
-
-  protected get finalizationViewer() {
-    return this._finalizationViewer
-  }
-
-  protected get initRewardsCache() {
-    return this.params.initRewardsCache ?? true
-  }
-
-  protected get networkStepRewardsByPositionViewer() {
-    return this._networkStepRewardsByPositionViewer!
-  }
-
-  protected get rewardMultipliers() {
-    this._rewardMultipliers = this._rewardMultipliers ?? this.params.rewardMultipliers ?? {}
-    return this._rewardMultipliers
-  }
-
-  async accountBalance(address: Address, config: ChainQualifiedConfig = {}) {
-    return await this.account.balance.accountBalance(address, config)
-  }
-
-  async accountBalanceHistory(address: Address, config: ChainQualifiedConfig = {}) {
-    return await this.account.balance.accountBalanceHistory(address, config)
-  }
-
-  async blockByHash(hash: Hash) {
-    return await this.block.blockByHash(hash)
-  }
-
-  async blockByNumber(blockNumber: XL1BlockNumber) {
-    return await this.block.blockByNumber(blockNumber)
-  }
-
-  async blocksByHash(hash: Hash, limit: number = 10) {
-    return await this.block.blocksByHash(hash, limit)
-  }
-
-  async blocksByNumber(blockNumber: XL1BlockNumber, limit: number = 10) {
-    return await this.block.blocksByNumber(blockNumber, limit)
-  }
-
-  async chainId(): Promise<ChainId>
-  async chainId(blockNumber: XL1BlockNumber): Promise<ChainId>
-  async chainId(blockNumber: 'latest'): Promise<ChainId>
-  async chainId(blockNumber: XL1BlockNumber | 'latest' = 'latest'): Promise<ChainId> {
-    return await this.spanAsync('SimpleXyoViewer:chainId', async () => {
-      const chainId = assertEx(
-        blockNumber === 'latest' ? this._chainId : await this.chainContractViewer.chainIdAtBlockNumber(blockNumber),
-        () => `Could not find block for chainId at block ${blockNumber}`,
-      )
-      return chainId
-    }, this.context)
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._accountBalanceViewer = await this.locator.getInstance<AccountBalanceViewer>(AccountBalanceViewerMoniker)
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-    this._chainContractViewer = await this.locator.getInstance<ChainContractViewer>(ChainContractViewerMoniker)
-    this._finalizationViewer = await this.locator.getInstance<FinalizationViewer>(FinalizationViewerMoniker)
-    this._mempoolViewer = await this.locator.getInstance<MempoolViewer>(MempoolViewerMoniker)
-    this._networkStakeViewer = await this.locator.getInstance<NetworkStakeViewer>(NetworkStakeViewerMoniker)
-    this._networkStepRewardsByPositionViewer
-      = await this.locator.getInstance<NetworkStakeStepRewardsByPositionViewer>(NetworkStakeStepRewardsByPositionViewerMoniker)
-    this._stakeViewer = await this.locator.getInstance<StakeViewer>(StakeViewerMoniker)
-    this._stepViewer = await this.locator.getInstance<StepViewer>(StepViewerMoniker)
-    this._timeSyncViewer = await this.locator.getInstance<TimeSyncViewer>(TimeSyncViewerMoniker)
-    this._transaction = await this.locator.getInstance<TransactionViewer>(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(): Promisable<ForkHistory> {
-    throw new Error('Method [forkHistory] not implemented.')
-  }
-
-  networkStakeStepRewardAddressHistory(_address: Address): Promise<Record<Address, AttoXL1>> {
-    throw new Error('Method [networkStakeStepRewardAddressHistory] not implemented.')
-  }
-
-  networkStakeStepRewardAddressReward(_context: StepIdentity, _address: Address): Promise<Record<Address, AttoXL1>> {
-    throw new Error('Method [networkStakeStepRewardAddressReward] not implemented.')
-  }
-
-  networkStakeStepRewardAddressShare(_context: StepIdentity, _address: Address): Promise<[bigint, bigint]> {
-    throw new Error('Method [networkStakeStepRewardAddressShare] not implemented.')
-  }
-
-  networkStakeStepRewardClaimedByAddress(_address: Address): Promise<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardClaimedByAddress] not implemented.')
-  }
-
-  async networkStakeStepRewardForPosition(position: number, range: XL1BlockRange): Promise<[AttoXL1, AttoXL1]> {
-    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 networkStakeStepRewardForStep(stepContext: StepIdentity): Promise<AttoXL1> {
-    return await stepRewardTotal(this.context, this.block, stepContext, this.rewardMultipliers)
-  }
-
-  async networkStakeStepRewardForStepForPosition(stepIdentity: StepIdentity, position: number): Promise<[AttoXL1, AttoXL1]> {
-    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: [AttoXL1, AttoXL1] = [positionReward, totalReward]
-      return result
-    })
-  }
-
-  async networkStakeStepRewardPoolRewards(step: StepIdentity): Promise<Record<Address, AttoXL1>> {
-    const stakes = await this.stake.stakesByStaked(XYO_NETWORK_STAKING_ADDRESS)
-    const rewards: [Address, [AttoXL1, AttoXL1]][] = []
-    for (const stake of stakes) {
-      rewards.push([stake.staker, (await this.networkStakeStepRewardForStepForPosition(
-        step,
-        stake.id,
-      ))])
-    }
-    const result: Record<Address, AttoXL1> = {}
-    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: StepIdentity): Promise<Record<Address, bigint>> {
-    throw new Error('Method [networkStakeStepRewardPoolShares] not implemented.')
-  }
-
-  async networkStakeStepRewardPositionWeight(stepContext: StepIdentity, position: number): Promise<bigint> {
-    return await networkStakeStepRewardPositionWeight(this.context, this.block, this.stake.stakeEvents, stepContext, position)
-  }
-
-  networkStakeStepRewardPotentialPositionLoss(_context: StepIdentity, _position: number): Promise<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardPotentialPositionLoss] not implemented.')
-  }
-
-  networkStakeStepRewardRandomizer(_context: StepIdentity): Promise<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardRandomizer] not implemented.')
-  }
-
-  async networkStakeStepRewardStakerCount(stepContext: StepIdentity): Promise<number> {
-    return Object.keys(await allStakersForStep(
-      this.context,
-      this.block,
-      this.stake.stakeEvents,
-      stepContext,
-      XYO_NETWORK_STAKING_ADDRESS,
-    )).length
-  }
-
-  networkStakeStepRewardUnclaimedByAddress(_address: Address): Promise<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardUnclaimedByAddress] not implemented.')
-  }
-
-  networkStakeStepRewardWeightForAddress(_context: StepIdentity, _address: Address): Promise<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardWeightForAddress] not implemented.')
-  }
-
-  async networkStakeStepRewardsForPosition(position: number, range: XL1BlockRange): Promise<Record<StepIdentityString, [AttoXL1, AttoXL1]>> {
-    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)] as [StepIdentityString, [AttoXL1, AttoXL1]]
-    }))
-    const result: Record<StepIdentityString, [AttoXL1, AttoXL1]> = {}
-    for (const [step, reward] of rewards) {
-      result[step] = reward
-    }
-    const filtered = Object.fromEntries(Object.entries(result).filter(([_, v]) => v[0] > 0n))
-    return filtered
-  }
-
-  async networkStakeStepRewardsForRange(range: XL1BlockRange): Promise<AttoXL1> {
-    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: number, range: XL1BlockRange): Promise<AttoXL1> {
-    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: Hash): Promisable<WithHashMeta<Payload> | null> {
-    throw new Error('Method [payloadByHash] not implemented.')
-  }
-
-  payloadsByHash(_hashes: Hash[]): Promisable<WithHashMeta<Payload>[]> {
-    throw new Error('Method [payloadsByHash] not implemented.')
-  }
-
-  async rate(range: XL1BlockRange, timeUnit?: keyof TimeDurations): Promise<BlockRate> {
-    return await this.block.rate(range, timeUnit)
-  }
-
-  async stakeById(id: number): Promise<Position> {
-    return await this.stake.stakeById(id)
-  }
-
-  async stakeByStaker(staker: Address, slot: number): Promise<Position> {
-    return await this.stake.stakeByStaker(staker, slot)
-  }
-
-  async stakedByStaker(staker: Address): Promise<Address[]> {
-    const result: Set<Address> = 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: Address): Promise<Position[]> {
-    return await this.stake.stakesByStaked(staked)
-  }
-
-  async stakesByStaker(staker: Address): Promise<Position[]> {
-    return await this.stake.stakesByStaker(staker)
-  }
-
-  async stepSizeRate(start: XL1BlockNumber, stepSizeIndex: StepIndex, count?: Count, timeUnit?: keyof TimeDurations): Promise<BlockRate> {
-    return await this.block.stepSizeRate(start, stepSizeIndex, count, timeUnit)
-  }
-
-  async timeDurationRate(
-    timeConfig: SingleTimeConfig,
-    startBlock: XL1BlockNumber,
-    timeUnit?: keyof TimeDurations,
-    toleranceMs?: number,
-    maxAttempts?: number,
-  ): Promise<BlockRate> {
-    return await this.block.timeDurationRate(timeConfig, startBlock, timeUnit, toleranceMs, maxAttempts)
-  }
-
-  async transactionByBlockHashAndIndex(blockHash: Hash, transactionIndex: number = 0) {
-    return await this.transaction.byBlockHashAndIndex(blockHash, transactionIndex)
-  }
-
-  async transactionByBlockNumberAndIndex(blockNumber: XL1BlockNumber, transactionIndex: number = 0) {
-    return await this.transaction.byBlockNumberAndIndex(blockNumber, transactionIndex)
-  }
-
-  async transactionByHash(transactionHash: Hash) {
-    return await this.transaction.byHash(transactionHash)
-  }
-
-  protected override async startHandler() {
-    try {
-      const currentBlockNumber = await this.currentBlockNumber()
-      // initialize functions that have slow initial call
-      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?.log(`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?.log(`SimpleXyoViewer: Precomputing networkStakeStepRewardForPosition for positions ${batch.at(0)} - ${batch.at(-1)}`)
-          await Promise.all(batch.map(async (_, position) => await this.networkStakeStepRewardForPosition(
-            position,
-            asXL1BlockRange([0, currentBlockNumber], { name: 'startHandler' }),
-          )))
-        }
-        this.logger?.log(`SimpleXyoViewer: Precomputed networkStakeStepRewardForPosition up to position ${positionCount - 1}`)
-      }
-    } catch (ex) {
-      this.logger?.error(`SimpleXyoViewer: Error during startHandler initialization: ${(ex as Error).message}`)
-      this.logger?.error((ex as Error).stack ?? '<No Stack>')
-      throw ex
-    }
-  }
-
-  protected async stepWeightedDenominator(stepIdentity: StepIdentity, staked?: Address): Promise<bigint> {
-    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)
-    })
-  }
-}

package/src/buildLocalGateway.ts

@@ -1,114 +0,0 @@
-import type {
-  AccountInstance, ArchivistInstance, WithHashMeta,
-} from '@xyo-network/sdk-js'
-import type { MapType } from '@xyo-network/xl1-protocol-lib'
-import type {
-  BalancesStepSummary, Config, TransfersStepSummary,
-} from '@xyo-network/xl1-protocol-sdk'
-import {
-  ProviderFactoryLocator, SimpleAccountBalanceViewer, SimpleBlockViewer, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer,
-  SimpleTimeSyncViewer, SimpleWindowedBlockViewer, SimpleXyoRunner,
-} from '@xyo-network/xl1-protocol-sdk'
-import type { TransportFactory } from '@xyo-network/xl1-rpc'
-import {
-  AccountBalanceViewerRpcSchemas, BlockViewerRpcSchemas,
-  JsonRpcAccountBalanceViewer, JsonRpcBlockViewer,
-  JsonRpcMempoolRunner, JsonRpcMempoolViewer, JsonRpcNetworkStakeStepRewardsViewer, JsonRpcNetworkStakeViewer, JsonRpcStakeTotalsViewer,
-  JsonRpcTimeSyncViewer, JsonRpcXyoRunner, JsonRpcXyoViewer, MempoolRunnerRpcSchemas, MempoolViewerRpcSchemas, NetworkStakeViewerRpcSchemas,
-  StakeTotalsViewerRpcSchemas, TimeSyncViewerRpcSchemas, XyoRunnerRpcSchemas, XyoViewerRpcSchemas,
-} from '@xyo-network/xl1-rpc'
-
-import { registerGatewayWithLocator } from './registerHelpers.ts'
-import { SimpleNetworkStakeViewer } from './SimpleNetworkStakeViewer.ts'
-import {
-  SimpleStepRewardsByPositionViewer, SimpleStepRewardsByStakerViewer, SimpleStepRewardsByStepViewer, SimpleStepRewardsTotalViewer, SimpleStepRewardsViewer,
-} from './SimpleStepRewards/index.ts'
-import { SimpleStepViewer } from './SimpleStepViewer.ts'
-import { SimpleXyoViewer } from './SimpleXyoViewer.ts'
-
-/** @deprecated Use locatorsFromConfig instead */
-export function buildEmptyProviderLocator(config: Config) {
-  return new ProviderFactoryLocator({
-    config, singletons: {}, caches: {},
-  })
-}
-
-/** @deprecated Use locatorsFromConfig instead */
-export function buildSimpleProviderLocatorV2(config: Config, account?: AccountInstance) {
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  const locator = buildEmptyProviderLocator(config)
-  locator.registerMany([
-    SimpleNetworkStakeViewer.factory<SimpleNetworkStakeViewer>(SimpleNetworkStakeViewer.dependencies, {}),
-    SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(SimpleTimeSyncViewer.dependencies, {}),
-    SimpleStepViewer.factory<SimpleStepViewer>(SimpleStepViewer.dependencies, {}),
-    SimpleStepRewardsViewer.factory<SimpleStepRewardsViewer>(SimpleStepRewardsViewer.dependencies, {}),
-    SimpleStepRewardsByPositionViewer.factory<SimpleStepRewardsByPositionViewer>(SimpleStepRewardsByPositionViewer.dependencies, {}),
-    SimpleStepRewardsByStakerViewer.factory<SimpleStepRewardsByStakerViewer>(SimpleStepRewardsByStakerViewer.dependencies, {}),
-    SimpleStepRewardsByStepViewer.factory<SimpleStepRewardsByStepViewer>(SimpleStepRewardsByStepViewer.dependencies, {}),
-    SimpleStepRewardsTotalViewer.factory<SimpleStepRewardsTotalViewer>(SimpleStepRewardsTotalViewer.dependencies, {}),
-    SimpleXyoRunner.factory<SimpleXyoRunner>(SimpleXyoRunner.dependencies, {}),
-  ])
-  return registerGatewayWithLocator(locator, account)
-}
-
-/** @deprecated Use locatorsFromConfig instead */
-export async function buildJsonRpcProviderLocatorV2(config: Config, transportFactory: TransportFactory, account?: AccountInstance) {
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  const locator = buildEmptyProviderLocator(config)
-  locator.registerMany([
-    JsonRpcStakeTotalsViewer.factory<JsonRpcStakeTotalsViewer>(
-      JsonRpcStakeTotalsViewer.dependencies,
-      { transport: await transportFactory(StakeTotalsViewerRpcSchemas) },
-    ),
-    JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>(
-      JsonRpcAccountBalanceViewer.dependencies,
-      { transport: await transportFactory(AccountBalanceViewerRpcSchemas) },
-    ),
-    JsonRpcBlockViewer.factory<JsonRpcBlockViewer>(JsonRpcBlockViewer.dependencies, { transport: await transportFactory(BlockViewerRpcSchemas) }),
-    JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>(JsonRpcMempoolRunner.dependencies, { transport: await transportFactory(MempoolRunnerRpcSchemas) }),
-    JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>(JsonRpcMempoolViewer.dependencies, { transport: await transportFactory(MempoolViewerRpcSchemas) }),
-    JsonRpcNetworkStakeViewer.factory<JsonRpcNetworkStakeViewer>(
-      JsonRpcNetworkStakeViewer.dependencies,
-      { transport: await transportFactory(NetworkStakeViewerRpcSchemas) },
-    ),
-    JsonRpcTimeSyncViewer.factory<JsonRpcTimeSyncViewer>(JsonRpcTimeSyncViewer.dependencies, { transport: await transportFactory(TimeSyncViewerRpcSchemas) }),
-    JsonRpcNetworkStakeStepRewardsViewer.factory<JsonRpcNetworkStakeStepRewardsViewer>(
-      JsonRpcNetworkStakeStepRewardsViewer.dependencies,
-      { transport: await transportFactory(NetworkStakeViewerRpcSchemas) },
-    ),
-    JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, { transport: await transportFactory(XyoRunnerRpcSchemas) }),
-    JsonRpcXyoViewer.factory<JsonRpcXyoViewer>(JsonRpcXyoViewer.dependencies, { transport: await transportFactory(XyoViewerRpcSchemas) }),
-  ])
-  return registerGatewayWithLocator(locator, account)
-}
-
-/** @deprecated Use locatorsFromConfig instead */
-export interface BuildLocalGatewayParams {
-  account?: AccountInstance
-  balancesSummaryMap: MapType<string, WithHashMeta<BalancesStepSummary>>
-  finalizedArchivist: ArchivistInstance
-  pendingBlocksArchivist: ArchivistInstance
-  pendingTransactionsArchivist: ArchivistInstance
-  transfersSummaryMap: MapType<string, WithHashMeta<TransfersStepSummary>>
-}
-
-/** @deprecated Use locatorsFromConfig instead */
-
-/** Builds a local gateway provider locator with the given configuration. */
-export function buildLocalGateway(config: Config, params: BuildLocalGatewayParams) {
-  const {
-    account, pendingTransactionsArchivist, pendingBlocksArchivist, balancesSummaryMap, transfersSummaryMap, finalizedArchivist,
-  } = params
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  const locator = buildSimpleProviderLocatorV2(config, account)
-  locator.registerMany([
-    SimpleMempoolViewer.factory<SimpleMempoolViewer>(SimpleMempoolViewer.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
-    SimpleMempoolRunner.factory<SimpleMempoolRunner>(SimpleMempoolRunner.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
-    SimpleAccountBalanceViewer.factory<SimpleAccountBalanceViewer>(SimpleAccountBalanceViewer.dependencies, { balancesSummaryMap, transfersSummaryMap }),
-    SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist }),
-    SimpleBlockViewer.factory<SimpleBlockViewer>(SimpleBlockViewer.dependencies, { finalizedArchivist }),
-    SimpleWindowedBlockViewer.factory<SimpleWindowedBlockViewer>(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 10_000, syncInterval: 10_000 }),
-    SimpleXyoViewer.factory<SimpleXyoViewer>(SimpleXyoViewer.dependencies, {}),
-  ])
-  return locator
-}