@xyo-network/xl1-protocol-sdk 1.26.11 → 1.26.13

package/src/primitives/step/stepTransferIndex.ts

@@ -1,19 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { StepSizes } from '@xyo-network/xl1-protocol-lib'
-
-/** StepTransferIndex helper function. */
-export function stepTransferIndex(block: number, step: number) {
-  let rewardTransferCount = 0
-  let rewardTransferIndex = -1
-  for (let i = 3; i < StepSizes.length; i++) {
-    const stepSize = StepSizes[i]
-    if (block % stepSize === 0) {
-      if (stepSize === StepSizes[step]) {
-        rewardTransferIndex = rewardTransferCount
-      }
-      rewardTransferCount++
-    }
-  }
-  assertEx(rewardTransferIndex >= 0, () => `Could not find step size for step ${step} at block ${block}`)
-  return [rewardTransferIndex, rewardTransferCount]
-}

package/src/primitives/transaction/elevatedPayloads.ts

@@ -1,24 +0,0 @@
-import type { WithHashMeta } from '@xyo-network/sdk-js'
-import type { AllowedBlockPayload, HydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-import { isAllowedBlockPayload } from '@xyo-network/xl1-protocol-lib'
-
-const ELEVATE_OPCODE = 'elevate'
-
-/** ElevatedPayloads helper function. */
-export function elevatedPayloads([tx, payloads]: HydratedTransactionWithHashMeta) {
-  const opCodes = (tx.script ?? []).filter(operation => operation.startsWith(`${ELEVATE_OPCODE}|`))
-  const elevatedPayloads: WithHashMeta<AllowedBlockPayload>[] = []
-  for (const opCode of opCodes) {
-    const [code, hash] = opCode.split('|')
-    if (code === ELEVATE_OPCODE) {
-      const elevatedPayload = payloads.find(payload => payload._hash === hash)
-      if (isAllowedBlockPayload(elevatedPayload)) {
-        elevatedPayloads.push(elevatedPayload)
-      }
-    }
-  }
-  if (opCodes.length === elevatedPayloads.length) {
-    return elevatedPayloads
-  }
-  throw new Error('Not all elevated payloads could be found in the transaction payloads')
-}

package/src/primitives/transaction/index.ts

@@ -1 +0,0 @@
-export * from './elevatedPayloads.ts'

package/src/primitives/uncle/findBestUncle.ts

@@ -1,9 +0,0 @@
-import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-
-import { scoreUncle } from './scoreUncle.ts'
-
-/** FindBestUncle helper function. */
-export function findBestUncle(finalizedWindowedChain: SignedHydratedBlockWithHashMeta[], uncles: SignedHydratedBlockWithHashMeta[][]) {
-  const scores = uncles.map(uncle => ([scoreUncle(finalizedWindowedChain, uncle), uncle] as const)).toSorted((a, b) => b[0] - a[0])
-  return scores[0]?.[1] ?? finalizedWindowedChain
-}

package/src/primitives/uncle/findUncles.ts

@@ -1,75 +0,0 @@
-import {
-  assertEx,
-  exists, type Hash,
-} from '@xylabs/sdk-js'
-import type { BaseContext, SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-import { isTransactionBoundWitness } from '@xyo-network/xl1-protocol-lib'
-
-function blocksToChains(blocks: SignedHydratedBlockWithHashMeta[]) {
-  const chains: SignedHydratedBlockWithHashMeta[][] = []
-  const map = new Map<Hash, SignedHydratedBlockWithHashMeta>()
-  for (const block of blocks) {
-    map.set(block[0]._hash, block)
-  }
-  for (const block of blocks) {
-    let uncle: SignedHydratedBlockWithHashMeta[] = [block]
-    let previous = block[0].previous ? map.get(block[0].previous) : undefined
-    while (previous) {
-      if (previous[0].block === (uncle[0][0].block - 1)) {
-        uncle.unshift(previous)
-        previous = previous[0].previous ? map.get(previous[0].previous) : undefined
-      } else {
-        // block number sequence is off
-        uncle = []
-        break
-      }
-    }
-    if (uncle.length > 0) {
-      chains.push(uncle)
-    }
-  }
-  return chains
-}
-
-function toValidUncle(
-  _context: BaseContext,
-  finalizedWindowedChain: SignedHydratedBlockWithHashMeta[],
-  possibleUncle: SignedHydratedBlockWithHashMeta[],
-) {
-  const finalizedWindowStartBlockNumber = finalizedWindowedChain.at(0)?.[0].block ?? -1
-  const finalizedHead = assertEx(finalizedWindowedChain.at(-1), () => 'finalizedWindowedChain is empty')
-  // prune the chain to match the finalized head
-
-  const prunedPossibleUncle = possibleUncle.filter(b => b[0].block > finalizedHead[0].block)
-
-  if (prunedPossibleUncle.length === 0) {
-    return
-  }
-
-  if (prunedPossibleUncle[0][0].block !== finalizedHead[0].block + 1) {
-    // uncle does not build on finalized head (block number mismatch)
-    return
-  }
-  if (prunedPossibleUncle[0][0].previous !== finalizedHead[0]._hash) {
-    // uncle does not build on finalized head (previous hash mismatch)
-    return
-  }
-  const allUncleTransactions = prunedPossibleUncle.flatMap(b => b[1]).filter(isTransactionBoundWitness)
-  const allFinalizedTransactions = finalizedWindowedChain.flatMap(b => b[1]).filter(isTransactionBoundWitness)
-  const txPossiblyBeforeWindow = allUncleTransactions.find(tx => tx.nbf < finalizedWindowStartBlockNumber)
-  if (txPossiblyBeforeWindow) {
-    // uncle has a transaction that is valid before the finalized window
-    return
-  }
-  const txExistsInWindow = allUncleTransactions.find(tx => allFinalizedTransactions.find(finalTx => finalTx._hash === tx._hash))
-  if (txExistsInWindow) {
-    // uncle has a transaction that is already in the finalized window
-    return
-  }
-  return prunedPossibleUncle
-}
-
-/** FindUncles helper function. */
-export function findUncles(context: BaseContext, finalizedWindowedChain: SignedHydratedBlockWithHashMeta[], blocks: SignedHydratedBlockWithHashMeta[]) {
-  return blocksToChains(blocks).map(chain => toValidUncle(context, finalizedWindowedChain, chain)).filter(exists)
-}

package/src/primitives/uncle/index.ts

@@ -1,3 +0,0 @@
-export * from './findBestUncle.ts'
-export * from './findUncles.ts'
-export * from './scoreUncle.ts'

package/src/primitives/uncle/scoreUncle.ts

@@ -1,7 +0,0 @@
-import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-
-/** ScoreUncle helper function. */
-export function scoreUncle(finalizedWindowedChain: SignedHydratedBlockWithHashMeta[], blocks: SignedHydratedBlockWithHashMeta[]) {
-  // TODO: More than length check
-  return blocks.length
-}

package/src/services/AccountTransfersService.ts

@@ -1,13 +0,0 @@
-import type {
-  Address, Hash, Promisable,
-} from '@xylabs/sdk-js'
-import type { AttoXL1 } from '@xyo-network/xl1-protocol-lib'
-
-/** Provider interface for querying transfer totals by account at a given chain head */
-export interface AccountTransfersProvider {
-  transfer(head: Hash, account: Address): Promisable<AttoXL1>
-  transfers(head: Hash, accounts: Address[]): Promisable<Partial<Record<Address, AttoXL1>>>
-}
-
-/** Service interface for querying account transfers, extending AccountTransfersProvider */
-export interface AccountTransfersService extends AccountTransfersProvider {}

package/src/services/BlockProducerService.ts

@@ -1,11 +0,0 @@
-import type {
-  Addressable,
-  BlockBoundWitness, IterableRepository,
-  SignedHydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-protocol-lib'
-
-/** Repository type for producing the next block from a block bound witness */
-export type NextBlockProducer = IterableRepository<BlockBoundWitness, SignedHydratedBlockWithHashMeta | undefined>
-
-/** Service interface for an addressable block producer */
-export interface BlockProducerService extends Addressable, NextBlockProducer {}

package/src/services/Chain/BaseChainService.ts

@@ -1,4 +0,0 @@
-/** Base interface for chain service implementations */
-export interface BaseChainService {
-
-}

package/src/services/Chain/ChainHeadService.ts

@@ -1,8 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-
-import type { BaseChainService } from './BaseChainService.ts'
-
-/** Service interface for tracking the current chain head hash */
-export interface ChainHeadService extends BaseChainService {
-  head: Hash | null
-}

package/src/services/Chain/ChainService.ts

@@ -1,6 +0,0 @@
-import type { ChainContractViewer, ChainStakeViewer } from '@xyo-network/xl1-protocol-lib'
-
-import type { BaseChainService } from './BaseChainService.ts'
-
-/** @deprecated use ChainContractViewer, StakeTotalsViewer, StakeRunner instead */
-export interface ChainService extends Omit<ChainContractViewer, 'moniker'>, Omit<ChainStakeViewer, 'moniker'>, BaseChainService {}

package/src/services/Chain/index.ts

@@ -1,3 +0,0 @@
-export * from './BaseChainService.ts'
-export * from './ChainHeadService.ts'
-export * from './ChainService.ts'

package/src/services/Election.ts

@@ -1,14 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type { WithHashMeta } from '@xyo-network/sdk-js'
-import type { BlockBoundWitness } from '@xyo-network/xl1-protocol-lib'
-
-/** Service for determining the block producer committee for the next block */
-export interface ElectionService {
-
-  /**
-   * Given the current block, get the leader for the next block
-   * @param current The previous block
-   */
-  getCreatorCommitteeForNextBlock(current: WithHashMeta<BlockBoundWitness>): Promise<Address[]>
-
-}

package/src/services/NetworkStakeService.ts

@@ -1,4 +0,0 @@
-import type { NetworkStakeStepRewardViewer } from '@xyo-network/xl1-protocol-lib'
-
-/** Service interface for viewing network stake step rewards */
-export interface NetworkStakeStepRewardService extends NetworkStakeStepRewardViewer {}

package/src/services/Params.ts

@@ -1,13 +0,0 @@
-import type { CreatableParams } from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import type { OpenTelemetryProviders } from '@xyo-network/xl1-protocol-lib'
-
-/** Base parameters for all services, including creatable params and OpenTelemetry providers */
-export interface BaseServiceParams extends CreatableParams, OpenTelemetryProviders {
-
-}
-
-/** Service parameters that include an account instance for signing operations */
-export interface BaseAccountableServiceParams extends BaseServiceParams {
-  account: AccountInstance
-}

package/src/services/PendingTransactionsService.ts

@@ -1,7 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol-lib'
-
-/** Service for retrieving pending transactions from the mempool */
-export interface PendingTransactionsService {
-  getPendingTransactions(head: Hash, limit: number, timeout?: number): Promise<SignedHydratedTransaction[]>
-}

package/src/services/SchemasService.ts

@@ -1,11 +0,0 @@
-import type { Hash, Promisable } from '@xylabs/sdk-js'
-import type { Schema } from '@xyo-network/sdk-js'
-
-/** Provider interface for querying schema counts at a given chain head */
-export interface SchemasProvider {
-  schema(head: Hash, schema: Schema): Promisable<number>
-  schemas(head: Hash, schemas: Schema[]): Promisable<Partial<Record<Schema, number>>>
-}
-
-/** Service interface for querying schema counts, extending SchemasProvider */
-export interface SchemasService extends SchemasProvider {}

package/src/services/StakeIntentService/ChainIndexingServiceStateSchema.ts

@@ -1,50 +0,0 @@
-import type { Hash, JsonValue } from '@xylabs/sdk-js'
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import type { Payload, WithStorageMeta } from '@xyo-network/sdk-js'
-import {
-  asSchema, isPayloadOfSchemaType, isStorageMeta,
-} from '@xyo-network/sdk-js'
-
-/** Fields stored by a chain indexing service to track its indexing progress and state */
-export interface ChainIndexingServiceStateFields<T extends JsonValue = JsonValue> {
-  /**
-   * The hash of the last block that this service has indexing
-   */
-  endBlockHash: Hash
-  /**
-   * The hash of the block that the service started indexing. If undefined, the service is
-   * assumed to have started indexing from the genesis block
-   */
-  startBlockHash?: Hash
-  /**
-   * The indexed state for the range
-   */
-  state: T
-}
-/** Schema identifier for chain indexing service state payloads */
-export const ChainIndexingServiceStateSchema = asSchema('network.xyo.chain.indexing.service.state', true)
-/** Schema type for ChainIndexingServiceState payloads. */
-export type ChainIndexingServiceStateSchema = typeof ChainIndexingServiceStateSchema
-
-/**
- * The result of a ChainIndexingServiceState
- */
-export type ChainIndexingServiceState<T extends JsonValue = JsonValue> = Payload<ChainIndexingServiceStateFields<T>, ChainIndexingServiceStateSchema>
-
-/**
- * Identity functions for determining if an object is an ChainIndexingServiceState
- */
-export const isChainIndexingServiceState = <T extends JsonValue = JsonValue>(payload?: unknown): payload is ChainIndexingServiceState<T> => {
-  return isPayloadOfSchemaType<ChainIndexingServiceState<T>>(ChainIndexingServiceStateSchema)(payload)
-}
-/** Type assertion factory for ChainIndexingServiceState payloads */
-export const asChainIndexingServiceState = AsObjectFactory.create<ChainIndexingServiceState<JsonValue>>(isChainIndexingServiceState)
-
-/** Type guard for ChainIndexingServiceState with storage metadata */
-export const isChainIndexingServiceStateWithStorageMeta
-  = <T extends JsonValue = JsonValue>(value: unknown): value is WithStorageMeta<ChainIndexingServiceState<T>> =>
-    isChainIndexingServiceState<T>(value) && isStorageMeta(value)
-
-/** Type assertion factory for ChainIndexingServiceState with storage metadata */
-export const asChainIndexingServiceStateWithStorageMeta
-  = AsObjectFactory.create<WithStorageMeta<ChainIndexingServiceState>>(isChainIndexingServiceStateWithStorageMeta)

package/src/services/StakeIntentService/StakeIntentService.ts

@@ -1,35 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type { Intent } from '@xyo-network/xl1-protocol-lib'
-
-/** Service for managing and querying stake intent declarations on the chain */
-export interface StakeIntentService {
-
-  /**
-   * Gets the declared ranges for an address based on historical on-chain data
-   * @param address The address to get the declared ranges for
-   * @param intent The declared intent to filter for
-   */
-  getDeclaredCandidateRanges(address: Address, intent: Intent): Promise<Readonly<Readonly<[number, number]>[]>>
-
-  /**
-   * Gets the declared candidates for a block based on historical on-chain data
-   * @param block The block number to get the declared candidates for
-   * @param intent The declared intent to filter for
-   */
-  getDeclaredCandidatesForBlock(block: number, intent: Intent): Promise<Address[]>
-
-  /**
-   * Gets the required minimum stake for a given intent
-   * @param intent The declared intent to filter for
-   * @returns The required minimum stake for the intent
-   */
-  getRequiredMinimumStakeForIntent(intent: Intent): bigint
-
-  /**
-   * Checks if the address is staked for a block for a given intent
-   * @param block The block number to check
-   * @param intent The declared intent to filter for
-   * @param address The address to check
-   */
-  isStakedForBlock(block: number, intent: Intent, address: Address): Promise<boolean>
-}

package/src/services/StakeIntentService/index.ts

@@ -1,2 +0,0 @@
-export * from './ChainIndexingServiceStateSchema.ts'
-export * from './StakeIntentService.ts'

package/src/services/index.ts

@@ -1,8 +0,0 @@
-export * from './AccountTransfersService.ts'
-export * from './BlockProducerService.ts'
-export * from './Chain/index.ts'
-export * from './Election.ts'
-export * from './NetworkStakeService.ts'
-export * from './PendingTransactionsService.ts'
-export * from './SchemasService.ts'
-export * from './StakeIntentService/index.ts'

package/src/simple/StakeEventsViewer/SimpleStakeEventsViewer.ts

@@ -1,93 +0,0 @@
-import { isDefined } from '@xylabs/sdk-js'
-import {
-  Position, StakeEvent, StakeEventFilter, StakeEventName, StakeEventsViewer, StakeEventsViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleStakeEvents. */
-export interface SimpleStakeEventsParams extends CreatableProviderParams {
-  positions: Position[]
-}
-
-/** SimpleStakeEventsViewer implementation. */
-@creatableProvider()
-export class SimpleStakeEventsViewer extends AbstractCreatableProvider<SimpleStakeEventsParams> implements StakeEventsViewer {
-  static readonly defaultMoniker = StakeEventsViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [StakeEventsViewerMoniker]
-  moniker = SimpleStakeEventsViewer.defaultMoniker
-
-  protected get positions() {
-    return this.params.positions
-  }
-
-  positionCount(range: [number, number | 'latest']): number {
-    return this.positionsFromRange(range).length
-  }
-
-  stakeEvents<TName extends StakeEventName>(range: [number, number | 'latest'], { name }: StakeEventFilter<TName> = {}): StakeEvent<TName>[] {
-    const positions = this.positionsFromRange(range)
-    const events = this.eventsFromPositions(positions)
-    if (isDefined(name)) {
-      return events.filter((event): event is StakeEvent<TName> => event.name === name)
-    }
-    return events as StakeEvent<TName>[]
-  }
-
-  protected override async startHandler(): Promise<void> {
-    await super.startHandler()
-  }
-
-  private eventsFromPositions(positions: Position[]): StakeEvent<StakeEventName>[] {
-    const events = positions.map((position) => {
-      const events: StakeEvent<StakeEventName>[] = [{
-        name: 'StakeAdded',
-        time: position.addBlock,
-        args: {
-          staker: position.staker,
-          staked: position.staked,
-          amount: position.amount,
-          id: position.id,
-        },
-      }]
-      if (position.removeBlock !== 0) {
-        events.push({
-          name: 'StakeRemoved',
-          time: position.removeBlock,
-          args: {
-            staker: position.staker,
-            staked: position.staked,
-            amount: position.amount,
-            id: position.id,
-          },
-        })
-      }
-      if (position.withdrawBlock !== 0) {
-        events.push({
-          name: 'StakeWithdrawn',
-          time: position.withdrawBlock,
-          args: {
-            staker: position.staker,
-            staked: position.staked,
-            amount: position.amount,
-            id: position.id,
-          },
-        })
-      }
-      return events
-    })
-    return events.flat()
-  }
-
-  private positionsFromRange(range: [number, number | 'latest']): Position[] {
-    const startBlock = range[0]
-    const endBlock = range[1] === 'latest' ? Number.MAX_SAFE_INTEGER : range[1]
-    const filteredPositions = this.positions?.filter((position) => {
-      return position.addBlock <= endBlock && (position.removeBlock === 0 || position.removeBlock >= startBlock)
-    }) ?? []
-    return filteredPositions
-  }
-}

package/src/simple/StakeEventsViewer/index.ts

@@ -1 +0,0 @@
-export * from './SimpleStakeEventsViewer.ts'

package/src/simple/StakeTotalsViewer/SimpleStakeTotalsViewer.ts

@@ -1,116 +0,0 @@
-import { type Address, asAddress } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import {
-  StakeTotalsViewer, StakeTotalsViewerMoniker,
-  StakeViewer,
-  StakeViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleStakeTotalsViewer. */
-export interface SimpleStakeTotalsViewerParams extends CreatableProviderParams {
-
-}
-
-/** SimpleStakeTotalsViewer implementation. */
-@creatableProvider()
-export class SimpleStakeTotalsViewer extends AbstractCreatableProvider<SimpleStakeTotalsViewerParams> implements StakeTotalsViewer {
-  static readonly defaultMoniker = StakeTotalsViewerMoniker
-  static readonly dependencies = [StakeTotalsViewerMoniker]
-  static readonly monikers = [StakeTotalsViewerMoniker]
-  moniker = SimpleStakeTotalsViewer.defaultMoniker
-
-  private _stakeViewer!: StakeViewer
-
-  get stakeViewer() {
-    return this._stakeViewer
-  }
-
-  async active(time = Number.MAX_SAFE_INTEGER) {
-    let active = 0n
-    const positions = await this.stakeViewer.activeStakes()
-    for (const position of positions) {
-      if (position.removeBlock === 0 || position.removeBlock > time) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  async activeByStaked(staked: Address, time = Number.MAX_SAFE_INTEGER) {
-    let active = 0n
-    const positions = await this.stakeViewer.activeStakes()
-    for (const position of positions) {
-      if ((position.removeBlock === 0 || position.removeBlock > time) && asAddress(position.staked) === asAddress(staked)) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  async activeByStaker(staker: Address, time = Number.MAX_SAFE_INTEGER) {
-    let active = 0n
-    const positions = await this.stakeViewer.activeStakes()
-    for (const position of positions) {
-      if ((position.removeBlock === 0 || position.removeBlock > time) && asAddress(position.staker) === asAddress(staker)) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._stakeViewer = assertEx(
-      (await this.locateAndCreate<StakeViewer>(StakeViewerMoniker)),
-      () => 'Failed to create StakeViewer',
-    )
-  }
-
-  async pending(time = Number.MAX_SAFE_INTEGER): Promise<bigint> {
-    let pending = 0n
-    const positions = await this.stakeViewer.removedStakes()
-    for (const position of positions) {
-      if ((position.removeBlock !== 0 && position.removeBlock <= time) && (position.withdrawBlock === 0 || position.withdrawBlock > time)) {
-        pending += position.amount
-      }
-    }
-    return pending
-  }
-
-  async pendingByStaker(staker: Address, time = Number.MAX_SAFE_INTEGER) {
-    let pending = 0n
-    const positions = await this.stakeViewer.removedStakes()
-    for (const position of positions) {
-      if ((position.removeBlock !== 0 && position.removeBlock <= time) && (position.withdrawBlock === 0 || position.withdrawBlock > time) && asAddress(position.staker) === asAddress(staker)) {
-        pending += position.amount
-      }
-    }
-    return pending
-  }
-
-  async withdrawn(time = Number.MAX_SAFE_INTEGER): Promise<bigint> {
-    let withdrawn = 0n
-    const positions = await this.stakeViewer.withdrawnStakes()
-    for (const position of positions) {
-      if (position.withdrawBlock !== 0 && position.withdrawBlock <= time) {
-        withdrawn += position.amount
-      }
-    }
-    return withdrawn
-  }
-
-  async withdrawnByStaker(staker: Address, time = Number.MAX_SAFE_INTEGER): Promise<bigint> {
-    let withdrawn = 0n
-    const positions = await this.stakeViewer.withdrawnStakes()
-    for (const position of positions) {
-      if (position.withdrawBlock !== 0 && position.withdrawBlock <= time && asAddress(position.staker) === asAddress(staker)) {
-        withdrawn += position.amount
-      }
-    }
-    return withdrawn
-  }
-}

package/src/simple/StakeTotalsViewer/index.ts

@@ -1 +0,0 @@
-export * from './SimpleStakeTotalsViewer.ts'