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

package/src/simple/StakeViewer/SimpleStakeViewer.ts

@@ -1,164 +0,0 @@
-import {
-  type Address, asAddress, Promisable, toAddress,
-} from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import {
-  Position, StakeEventsViewer, StakeEventsViewerMoniker, StakeViewer, StakeViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleStakeViewer. */
-export interface SimpleStakeViewerParams extends CreatableProviderParams {
-  chainId?: Address
-  minWithdrawalBlocks?: number
-  positions: Position[]
-}
-
-/** SimpleStakeViewer implementation. */
-@creatableProvider()
-export class SimpleStakeViewer extends AbstractCreatableProvider<SimpleStakeViewerParams> implements StakeViewer {
-  static readonly defaultMoniker = StakeViewerMoniker
-  static readonly dependencies = [StakeEventsViewerMoniker]
-  static readonly monikers = [StakeViewerMoniker]
-  moniker = SimpleStakeViewer.defaultMoniker
-
-  private _chainStakeEventsViewer: StakeEventsViewer | undefined
-
-  get stakeEvents() {
-    return assertEx(this._chainStakeEventsViewer, () => 'Stake events viewer not set')
-  }
-
-  protected get positions() {
-    return this.params.positions
-  }
-
-  async active(): Promise<bigint> {
-    let active = 0n
-    const positions = await this.activeStakes()
-    for (const position of positions) {
-      if (position.removeBlock === 0) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  async activeByAddressStaked(staked: Address) {
-    let active = 0n
-    const positions = await this.activeStakes()
-    for (const position of positions) {
-      if (position.removeBlock === 0 && asAddress(position.staked) === asAddress(staked)) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  async activeByStaker(staker: Address): Promise<bigint> {
-    let active = 0n
-    const positions = await this.activeStakes()
-    for (const position of positions) {
-      if (position.removeBlock === 0 && asAddress(position.staker) === asAddress(staker)) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  activeStakes(): Promisable<Position[]> {
-    return this.positions.filter(s => (s.withdrawBlock === 0) && (s.removeBlock === 0))
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._chainStakeEventsViewer = assertEx(
-      (await this.locateAndCreate<StakeEventsViewer>(StakeEventsViewerMoniker)),
-      () => 'Failed to create StakeEventsViewer',
-    )
-  }
-
-  minWithdrawalBlocks(): number {
-    return this.params.minWithdrawalBlocks ?? 10
-  }
-
-  async pending() {
-    let pending = 0n
-    const positions = await this.removedStakes()
-    for (const position of positions) {
-      if (position.removeBlock !== 0 && position.withdrawBlock === 0) {
-        pending += position.amount
-      }
-    }
-    return pending
-  }
-
-  async pendingByStaker(staker: Address) {
-    let pending = 0n
-    const positions = await this.removedStakes()
-    for (const position of positions) {
-      if (position.removeBlock !== 0 && position.withdrawBlock === 0 && asAddress(position.staker) === asAddress(staker)) {
-        pending += position.amount
-      }
-    }
-    return pending
-  }
-
-  removedStakes(): Promisable<Position[]> {
-    return this.positions.filter(s => (s.withdrawBlock === 0) && (s.removeBlock !== 0))
-  }
-
-  rewardsContract(): Address {
-    return toAddress(toAddress(1n))
-  }
-
-  stakeById(id: number): Position {
-    return assertEx(this.positions[id], () => new Error(`Stake with id ${id} not found`))
-  }
-
-  stakeByStaker(staker: Address, slot: number): Position {
-    return this.positions.filter(s => asAddress(s.staker) === asAddress(staker))[slot]
-  }
-
-  stakesByStaked(staked: Address, range: [number, number | undefined] = [0, undefined]): Position[] {
-    const endBlock = (range[1] ?? Number.MAX_SAFE_INTEGER)
-    return this.positions.filter(s => asAddress(s.staked) === asAddress(staked) && s.addBlock <= endBlock && s.removeBlock <= endBlock)
-  }
-
-  stakesByStaker(staker: Address, range: [number, number | undefined] = [0, undefined]): Position[] {
-    const endBlock = (range[1] ?? Number.MAX_SAFE_INTEGER)
-    return this.positions.filter(s => asAddress(s.staker) === asAddress(staker) && s.addBlock <= endBlock && s.removeBlock <= endBlock)
-  }
-
-  stakingTokenAddress(): Address {
-    return toAddress('0x000000000000000000000000000011')
-  }
-
-  async withdrawn() {
-    let withdrawn = 0n
-    const positions = await this.withdrawnStakes()
-    for (const position of positions) {
-      if (position.withdrawBlock !== 0) {
-        withdrawn += position.amount
-      }
-    }
-    return withdrawn
-  }
-
-  async withdrawnByStaker(staker: Address) {
-    let withdrawn = 0n
-    const positions = await this.withdrawnStakes()
-    for (const position of positions) {
-      if (position.withdrawBlock !== 0 && asAddress(position.staker) === asAddress(staker)) {
-        withdrawn += position.amount
-      }
-    }
-    return withdrawn
-  }
-
-  withdrawnStakes(): Promisable<Position[]> {
-    return this.positions.filter(s => (s.withdrawBlock !== 0))
-  }
-}

package/src/simple/StakeViewer/index.ts

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

package/src/simple/TransactionViewer/SimpleTransactionViewer.ts

@@ -1,100 +0,0 @@
-import {
-  assertEx, exists, Hash,
-} from '@xylabs/sdk-js'
-import { BoundWitnessSchema } from '@xyo-network/sdk-js'
-import {
-  asSignedHydratedTransactionWithHashMeta,
-  asSignedTransactionBoundWitness,
-  BlockViewer,
-  BlockViewerMoniker,
-  isTransactionBoundWitnessWithHashMeta,
-  SignedHydratedTransactionWithHashMeta, TransactionViewer, TransactionViewerMoniker,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleTransactionViewer. */
-export interface SimpleTransactionViewerParams extends CreatableProviderParams {
-
-}
-
-/** SimpleTransactionViewer implementation. */
-@creatableProvider()
-export class SimpleTransactionViewer extends AbstractCreatableProvider<SimpleTransactionViewerParams> implements TransactionViewer {
-  static readonly defaultMoniker = TransactionViewerMoniker
-  static readonly dependencies = [BlockViewerMoniker]
-  static readonly monikers = [TransactionViewerMoniker]
-  moniker = SimpleTransactionViewer.defaultMoniker
-
-  private _blockViewer!: BlockViewer
-
-  protected get blockViewer() {
-    return this._blockViewer
-  }
-
-  async byBlockHashAndIndex(blockHash: Hash, transactionIndex: number): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.spanAsync('byBlockHashAndIndex', async () => {
-      assertEx(transactionIndex >= 0, () => 'transactionIndex must be greater than or equal to 0')
-      try {
-        const block = await this.blockViewer.blockByHash(blockHash)
-        if (!block) return null
-        const blockBoundWitnessIndexes = block[0].payload_schemas.map((schema, index) => schema === BoundWitnessSchema ? index : undefined).filter(exists)
-        const blockBoundWitnessHashes = new Set(blockBoundWitnessIndexes.map(index => block[0].payload_hashes[index]))
-        const blockBoundWitnesses = block[1].filter(payload => blockBoundWitnessHashes.has(payload._hash) || blockBoundWitnessHashes.has(payload._dataHash))
-        const blockTransactionBoundWitnesses = blockBoundWitnesses.filter(isTransactionBoundWitnessWithHashMeta)
-        const transaction = blockTransactionBoundWitnesses.at(transactionIndex)
-        if (!transaction) return null
-        return await this.byHash(transaction._hash)
-      } catch {
-        return null
-      }
-    }, this.context)
-  }
-
-  async byBlockNumberAndIndex(blockNumber: XL1BlockNumber, transactionIndex: number): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.spanAsync('byBlockNumberAndIndex', async () => {
-      try {
-        const block = await this.blockViewer.blockByNumber(blockNumber)
-        if (!block) return null
-        return await this.byBlockHashAndIndex(block[0]._hash, transactionIndex)
-      } catch {
-        return null
-      }
-    }, this.context)
-  }
-
-  async byHash(transactionHash: Hash): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.spanAsync('byHash', async () => {
-      try {
-        const transaction = asSignedTransactionBoundWitness(await this.blockViewer.payloadByHash(transactionHash))
-        if (transaction) {
-          const payloads = await this.blockViewer.payloadsByHash(transaction.payload_hashes)
-          return asSignedHydratedTransactionWithHashMeta([transaction, payloads]) ?? null
-        }
-        return null
-      } catch {
-        return null
-      }
-    }, this.context)
-  }
-
-  override async createHandler(): Promise<void> {
-    await super.createHandler()
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-  }
-
-  async transactionByBlockHashAndIndex(blockHash: Hash, transactionIndex: number = 0): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.byBlockHashAndIndex(blockHash, transactionIndex)
-  }
-
-  async transactionByBlockNumberAndIndex(blockNumber: XL1BlockNumber, transactionIndex: number = 0): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.byBlockNumberAndIndex(blockNumber, transactionIndex)
-  }
-
-  async transactionByHash(transactionHash: Hash): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.byHash(transactionHash)
-  }
-}

package/src/simple/TransactionViewer/index.ts

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

package/src/simple/accountBalance/SimpleAccountBalanceViewer.ts

@@ -1,271 +0,0 @@
-import type { Address, Hash } from '@xylabs/sdk-js'
-import {
-  asHash,
-  assertEx, exists, isDefined,
-  ZERO_ADDRESS,
-} from '@xylabs/sdk-js'
-import type { WithHashMeta, WithStorageMeta } from '@xyo-network/sdk-js'
-import type {
-  AccountBalanceConfig,
-  AccountBalanceHistoryItem,
-  AccountBalanceViewer,
-  BlockViewer,
-  ChainQualification,
-  ChainQualified,
-  MapType,
-  SignedBlockBoundWitnessWithHashMeta, Transfer, XL1BlockNumber, XL1BlockRange,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  AccountBalanceViewerMoniker,
-  asRange, asXL1BlockNumber, asXL1BlockRange, AttoXL1,
-  BlockViewerMoniker,
-  isChainQualifiedHeadConfig,
-  isChainQualifiedRangeConfig,
-  StepSizes,
-  TransferSchema,
-} from '@xyo-network/xl1-protocol-lib'
-import { Semaphore } from 'async-mutex'
-
-import { deepCalculateFramesFromRange } from '../../block/index.ts'
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import type { BalancesStepSummary, TransfersStepSummary } from '../../summary/index.ts'
-import {
-  balancesSummary,
-  transfersStepSummaryFromRange,
-} from '../../summary/index.ts'
-
-/** Parameters for SimpleAccountBalanceViewer. */
-export interface SimpleAccountBalanceViewerParams extends CreatableProviderParams {
-  balancesSummaryMap: MapType<string, WithHashMeta<BalancesStepSummary>>
-  transfersSummaryMap: MapType<string, WithHashMeta<TransfersStepSummary>>
-}
-
-/** SimpleAccountBalanceViewer implementation. */
-@creatableProvider()
-export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<SimpleAccountBalanceViewerParams> implements AccountBalanceViewer {
-  static readonly defaultMoniker = AccountBalanceViewerMoniker
-  static readonly dependencies = [BlockViewerMoniker]
-  static readonly monikers = [AccountBalanceViewerMoniker]
-  moniker = SimpleAccountBalanceViewer.defaultMoniker
-
-  private _balanceStepSemaphores = StepSizes.map(() => new Semaphore(20))
-  private _blockViewer!: BlockViewer
-  private _transferStepSemaphores = StepSizes.map(() => new Semaphore(20))
-
-  get balancesSummaryMap() {
-    return this.params.balancesSummaryMap
-  }
-
-  get blockViewer() {
-    return this._blockViewer
-  }
-
-  get transfersSummaryMap() {
-    return this.params.transfersSummaryMap
-  }
-
-  static override async paramsHandler(params: Partial<SimpleAccountBalanceViewerParams> = {}) {
-    return {
-      ...await super.paramsHandler(params),
-      balancesSummaryMap: assertEx(params.balancesSummaryMap, () => 'balancesSummaryMap is required'),
-      transfersSummaryMap: assertEx(params.transfersSummaryMap, () => 'transfersSummaryMap is required'),
-    }
-  }
-
-  async accountBalance(address: Address, config?: AccountBalanceConfig) {
-    const balances = await this.accountBalances([address], config)
-    return balances[address] ?? AttoXL1(0n)
-  }
-
-  async accountBalanceHistories(addresses: Address[], config: AccountBalanceConfig = {}) {
-    return (await this.qualifiedAccountBalanceHistories(addresses, config))[0]
-  }
-
-  async accountBalanceHistory(address: Address, config?: AccountBalanceConfig) {
-    return await this.spanAsync('accountBalanceHistory', async () => {
-      const range = isChainQualifiedRangeConfig(config) ? config.range : undefined
-      const startingRange = asXL1BlockRange(range ?? [0, await this.blockViewer.currentBlockNumber()], true)
-      const blockNumbers = await this.distillTransferHistory(address, startingRange)
-      const blocks = (await Promise.all(blockNumbers.map(async bn => await this.blockViewer.blockByNumber(bn)))).filter(exists)
-      const result: AccountBalanceHistoryItem[] = []
-      for (const block of blocks) {
-        const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : undefined).filter(exists)
-        const transfers = transferIndexes.map((index) => {
-          const hash = block[0].payload_hashes[index]
-          return assertEx(
-            block[1].find(p => p._hash === hash) as WithStorageMeta<Transfer>,
-            () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`,
-          )
-        }).filter(exists).filter(t => ((t.from === address) || (isDefined(t.transfers[address]))))
-        if (transfers.length === 0) {
-          continue
-        }
-        const pairs: [SignedBlockBoundWitnessWithHashMeta, WithHashMeta<Transfer>][] = (transfers.map((transfer) => {
-          return [block[0], transfer]
-        }))
-        result.push(...pairs.map(([block, transfer]) => [block,
-          null,
-          transfer] satisfies AccountBalanceHistoryItem))
-      }
-      return result
-    }, this.context)
-  }
-
-  async accountBalances(address: Address[], config?: AccountBalanceConfig) {
-    const [result] = (await this.qualifiedAccountBalances(address, config ?? {}))
-    return result
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-  }
-
-  async qualifiedAccountBalanceHistories(
-    addresses: Address[],
-    config: AccountBalanceConfig,
-  ) {
-    return await this.spanAsync('qualifiedAccountBalanceHistories', async () => {
-      const head = isChainQualifiedHeadConfig(config) ? config.head : await this.blockViewer.currentBlockHash()
-      const range = isChainQualifiedRangeConfig(config)
-        ? config.range
-        : asXL1BlockRange([0,
-            assertEx(
-              await this.blockViewer.blockByHash(head),
-              () => `Error: Could not find block with hash ${head}`,
-            )[0].block])
-      const qualifiedEntries = await Promise.all(addresses.map(async address => ([
-        address,
-        await this.qualifiedAccountBalanceHistory(address, range),
-      ]))) satisfies [Address, ChainQualified<AccountBalanceHistoryItem[]>][]
-
-      const entries = qualifiedEntries.map(([address, [history]]) => {
-        return [address, history]
-      })
-      const qualifiedRange = qualifiedEntries[0][1][1].range
-      const qualifiedHeadHash = qualifiedEntries[0][1][1].head
-
-      // check for drift
-      for (const [_, [__, { range, head }]] of qualifiedEntries) {
-        assertEx(
-          range[0] === qualifiedRange[0] && range[1] === qualifiedRange[1],
-          () => 'Inconsistent ranges in qualifiedAccountBalanceHistories',
-        )
-        assertEx(
-          head === qualifiedHeadHash,
-          () => 'Inconsistent head hashes in qualifiedAccountBalanceHistories',
-        )
-      }
-
-      return [Object.fromEntries(entries), { range: qualifiedRange, head: qualifiedHeadHash }] satisfies
-      [Record<Address, AccountBalanceHistoryItem[]>, ChainQualification]
-    }, this.context)
-  }
-
-  async qualifiedAccountBalances(
-    address: Address[],
-    config: AccountBalanceConfig,
-  ): Promise<ChainQualified<Record<Address, AttoXL1>>> {
-    return await this.spanAsync('qualifiedAccountsBalances', async () => {
-      const qualifiedSummary = await balancesSummary(
-        this.context,
-        this._balanceStepSemaphores,
-        this.blockViewer,
-        this.balancesSummaryMap,
-        config,
-      )
-      const result: Record<Address, AttoXL1> = {}
-      for (const addr of address) {
-        const summaryBalance = qualifiedSummary[0][addr] ?? 0n
-        result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance)
-      }
-      return [result, qualifiedSummary[1]]
-    }, this.context)
-  }
-
-  override async startHandler() {
-    await super.startHandler()
-    await Promise.all([
-      this.accountBalance(ZERO_ADDRESS),
-      this.accountBalanceHistory(ZERO_ADDRESS),
-    ])
-  }
-
-  private async distillTransferHistory(address: Address, range: XL1BlockRange, max: number = 50): Promise<XL1BlockNumber[]> {
-    return await this.spanAsync('distillTransferHistory', async () => {
-      if ((range[1] - range[0]) <= StepSizes[0] || max <= 1) {
-        return Array.from({ length: range[1] - range[0] + 1 }, (_, i) => range[1] - i).slice(0, max).map(n => asXL1BlockNumber(n, true))
-      }
-      const frames = deepCalculateFramesFromRange(asXL1BlockRange(range, true))
-      const transferSummaryPairs = await Promise.all(frames.map(
-        async (frame) => {
-          return [frame, await transfersStepSummaryFromRange(this.context, this._transferStepSemaphores, this.blockViewer, this.transfersSummaryMap, frame)]
-        },
-      )) as [XL1BlockRange, WithStorageMeta<TransfersStepSummary>][]
-
-      const filteredTransferSummaryPairs = transferSummaryPairs.filter(([_, summary]) => Object.keys(summary.transfers).includes(address))
-
-      // sort it latest to earliest
-      const sortedTransferSummaryPairs = filteredTransferSummaryPairs.toSorted((a, b) => {
-        return b[0][1] - a[0][1]
-      })
-
-      const resultBlockNumbers: Set<XL1BlockNumber> = new Set()
-      for (const [frame] of sortedTransferSummaryPairs) {
-        if ((frame[1] - frame[0] + 1) > StepSizes[0]) {
-          const values = await this.distillTransferHistory(address, asXL1BlockRange([frame[0], frame[1] - 1], true), max - resultBlockNumbers.size)
-          for (const value of values) {
-            resultBlockNumbers.add(value)
-          }
-          resultBlockNumbers.add(frame[1])
-        } else {
-          for (let i = frame[0]; i <= frame[1]; i++) {
-            resultBlockNumbers.add(i)
-          }
-        }
-        if (resultBlockNumbers.size >= max) {
-          break
-        }
-      }
-      return [...resultBlockNumbers].toSorted((a, b) => b - a).slice(0, max)
-    }, this.context)
-  }
-
-  private async qualifiedAccountBalanceHistory(
-    address: Address,
-    headOrRange?: Hash | XL1BlockRange,
-  ): Promise<ChainQualified<AccountBalanceHistoryItem[]>> {
-    return await this.spanAsync('qualifiedAccountBalanceHistory', async () => {
-      const range = asRange(headOrRange)
-      const headHash = asHash(headOrRange)
-      const [head] = assertEx(isDefined(headHash)
-        ? (await this.blockViewer.blockByHash(headHash))
-        : (await this.blockViewer.currentBlock()), () => 'Could not resolve head block')
-      const startingRange = asXL1BlockRange(range ?? [0, head.block], true)
-      const blockNumbers = await this.distillTransferHistory(address, startingRange)
-      const blocks = (await Promise.all(blockNumbers.map(async bn => await this.blockViewer.blockByNumber(bn)))).filter(exists)
-      const result: AccountBalanceHistoryItem[] = []
-      for (const block of blocks) {
-        const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : undefined).filter(exists)
-        const transfers = transferIndexes.map((index) => {
-          const hash = block[0].payload_hashes[index]
-          return assertEx(
-            block[1].find(p => p._hash === hash) as WithStorageMeta<Transfer>,
-            () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`,
-          )
-        }).filter(exists).filter(t => ((t.from === address) || (isDefined(t.transfers[address]))))
-        if (transfers.length === 0) {
-          continue
-        }
-        const pairs: [SignedBlockBoundWitnessWithHashMeta, WithHashMeta<Transfer>][] = (transfers.map((transfer) => {
-          return [block[0], transfer]
-        }))
-        result.push(...pairs.map(([block, transfer]) => [block,
-          null,
-          transfer] satisfies AccountBalanceHistoryItem))
-      }
-      return [result, { range: startingRange, head: head._hash }]
-    }, this.context)
-  }
-}

package/src/simple/accountBalance/index.ts

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