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

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'

package/src/simple/block/SimpleBlockViewer.ts

@@ -1,231 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import {
-  assertEx, exists, isUndefined,
-} from '@xylabs/sdk-js'
-import type {
-  Payload, ReadArchivist, WithHashMeta,
-} from '@xyo-network/sdk-js'
-import {
-  asSignedHydratedBlockWithHashMeta, asSignedHydratedBlockWithStorageMeta, asXL1BlockNumber,
-  BlockContextRead,
-  BlockRate, BlockViewer, BlockViewerMoniker, ChainContextRead,
-  ChainId, DataLakeViewer, DataLakeViewerMoniker, FinalizationViewer, FinalizationViewerMoniker, type SignedHydratedBlockWithHashMeta,
-  SignedHydratedBlockWithStorageMeta, SingleTimeConfig, TimeDurations, type XL1BlockNumber, XL1BlockRange,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { hydrateBlock } from '../../block/index.ts'
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import { LruCacheMap } from '../../driver/index.ts'
-import { ChainStoreRead } from '../../model/index.ts'
-import {
-  addDataLakePayloads,
-  addDataLakePayloadsToPayloads,
-  calculateBlockRate, calculateStepSizeRate, calculateTimeRate, hydratedBlockByNumber,
-} from '../../primitives/index.ts'
-import { HydratedCache } from '../../utils/index.ts'
-
-/** Parameters for SimpleBlockViewer. */
-export interface SimpleBlockViewerParams extends CreatableProviderParams {
-  finalizedArchivist: ReadArchivist
-}
-
-/** SimpleBlockViewer implementation. */
-@creatableProvider()
-export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockViewerParams> implements BlockViewer {
-  static readonly defaultMoniker = BlockViewerMoniker
-  static readonly dependencies = [FinalizationViewerMoniker]
-  static readonly monikers = [BlockViewerMoniker]
-  moniker = SimpleBlockViewer.defaultMoniker
-
-  protected _store?: ChainStoreRead
-  protected dataLakeViewer?: DataLakeViewer
-  protected finalizationViewer!: FinalizationViewer
-  protected payloadCache = new LruCacheMap<Hash, WithHashMeta<Payload>>({ max: 10_000 })
-  protected signedHydratedBlockWithDataLakePayloadsCache = new LruCacheMap<Hash, SignedHydratedBlockWithHashMeta>({ max: 2000, ttl: 1000 * 60 * 60 })
-
-  private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithStorageMeta> | undefined
-
-  get finalizedArchivist(): ReadArchivist {
-    return this.params.finalizedArchivist
-  }
-
-  protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithStorageMeta> {
-    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
-    const context = this.getBlockContextRead()
-    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithStorageMeta>(context, async (
-      context,
-      hash: Hash,
-      maxDepth?: number,
-      minDepth?: number,
-    ) => {
-      const result = await hydrateBlock(context, hash, maxDepth, minDepth)
-      return asSignedHydratedBlockWithStorageMeta(result, true)
-    }, 20_000)
-    return this._signedHydratedBlockCache
-  }
-
-  protected get store() {
-    return this._store!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleBlockViewerParams>) {
-    return {
-      ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx(params.finalizedArchivist, () => 'finalizedArchivist is required'),
-    } satisfies SimpleBlockViewerParams
-  }
-
-  async blockByHash(hash: Hash): Promise<SignedHydratedBlockWithHashMeta | null> {
-    return await this.spanAsync('blockByHash', async () => {
-      const cachedBlock = this.signedHydratedBlockWithDataLakePayloadsCache.get(hash)
-      if (cachedBlock) {
-        return cachedBlock
-      }
-
-      const cache = this.hydratedBlockCache
-      const block = await cache.get(hash)
-      const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []]
-      if (result) {
-        this.signedHydratedBlockWithDataLakePayloadsCache.set(hash, result)
-      }
-      return result
-    }, { ...this.context, timeBudgetLimit: 100 })
-  }
-
-  async blockByNumber(blockNumber: XL1BlockNumber): Promise<SignedHydratedBlockWithHashMeta | null> {
-    return await this.spanAsync('blockByNumber', async () => {
-      const chainContext = await this.getChainContextRead()
-      if (isUndefined(chainContext.head)) {
-        return null
-      }
-      return await this.blockByNumberWithContext(chainContext, blockNumber)
-    }, { ...this.context, timeBudgetLimit: 100 })
-  }
-
-  async blocksByHash(hash: Hash, limit = 50): Promise<SignedHydratedBlockWithHashMeta[]> {
-    return await this.spanAsync('blocksByHash', async () => {
-      assertEx(limit > 0, () => 'limit must be greater than 0')
-      assertEx(limit <= 100, () => 'limit must be less than 100')
-      const blocks: SignedHydratedBlockWithHashMeta[] = []
-      let current = await this.blockByHash(hash)
-      while (current && blocks.length < limit) {
-        blocks.push(current)
-        const previousHash = current[0].previous
-        if (previousHash === null) break
-        current = await this.blockByHash(previousHash)
-      }
-      return blocks.map(b => asSignedHydratedBlockWithHashMeta(b, true))
-    }, { ...this.context, timeBudgetLimit: 300 })
-  }
-
-  async blocksByNumber(blockNumber: XL1BlockNumber, limit = 50): Promise<SignedHydratedBlockWithHashMeta[]> {
-    return await this.spanAsync('blocksByNumber', async () => {
-      assertEx(limit > 0, () => 'limit must be greater than 0')
-      assertEx(limit <= 100, () => 'limit must be less than 100')
-      const chainContext = await this.getChainContextRead()
-      if (isUndefined(chainContext.head)) {
-        return []
-      }
-      const blocks: SignedHydratedBlockWithHashMeta[] = []
-      let current = await this.blockByNumberWithContext(chainContext, blockNumber)
-      while (current && blocks.length < limit) {
-        blocks.push(current)
-        if (current[0].block === 0) break
-        const previousNumber = asXL1BlockNumber(current[0].block - 1, true)
-        current = await this.blockByNumberWithContext(chainContext, previousNumber)
-      }
-      return blocks.map(b => asSignedHydratedBlockWithHashMeta(b, true))
-    }, this.context)
-  }
-
-  chainId(): Promise<ChainId>
-  chainId(blockNumber: XL1BlockNumber): Promise<ChainId>
-  chainId(blockNumber: 'latest'): Promise<ChainId>
-  async chainId(blockNumber: XL1BlockNumber | 'latest' = 'latest'): Promise<ChainId> {
-    return await this.spanAsync('chainId', async () => {
-      return blockNumber === 'latest' ? (await this.finalizationViewer.headBlock()).chain : assertEx((await this.blockByNumber(blockNumber)), () => `Block not found [${blockNumber}]`)[0].chain
-    }, this.context)
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this.dataLakeViewer = await this.locator.tryGetInstance<DataLakeViewer>(DataLakeViewerMoniker)
-    this.finalizationViewer = await this.locator.getInstance<FinalizationViewer>(FinalizationViewerMoniker)
-    this._store = { chainMap: this.params.finalizedArchivist }
-  }
-
-  async currentBlock(): Promise<SignedHydratedBlockWithHashMeta> {
-    const [result] = await addDataLakePayloads(await this.finalizationViewer.head(), this.dataLakeViewer)
-    return result
-  }
-
-  async currentBlockHash(): Promise<Hash> {
-    return await this.finalizationViewer.headHash()
-  }
-
-  async currentBlockNumber(): Promise<XL1BlockNumber> {
-    return await this.finalizationViewer.headNumber()
-  }
-
-  async payloadByHash(hash: Hash): Promise<WithHashMeta<Payload> | null> {
-    const [payload] = await this.payloadsByHash([hash])
-    return payload ?? null
-  }
-
-  async payloadsByHash(hashes: Hash[]): Promise<WithHashMeta<Payload>[]> {
-    let remainingHashes = [...hashes]
-    const cachedPayloads = this.payloadCache.getMany(remainingHashes)
-    const cachedHashes = new Set(cachedPayloads.map(p => p._hash))
-    remainingHashes = remainingHashes.filter(h => !cachedHashes.has(h))
-    const finalizedPayloads = remainingHashes.length > 0
-      ? await this.finalizedArchivist.get(remainingHashes)
-      : []
-    const [resultPayloads] = await addDataLakePayloadsToPayloads(hashes, [...cachedPayloads, ...finalizedPayloads.filter(exists)], this.dataLakeViewer)
-    resultPayloads.map((payload) => {
-      this.payloadCache.set(payload._hash, payload)
-    })
-    return resultPayloads
-  }
-
-  async rate(range: XL1BlockRange, timeUnit?: keyof TimeDurations): Promise<BlockRate> {
-    return await calculateBlockRate(this, range, timeUnit)
-  }
-
-  async stepSizeRate(start: XL1BlockNumber, stepIndex: number, count = 1, timeUnit?: keyof TimeDurations): Promise<BlockRate> {
-    return await calculateStepSizeRate(this, start, stepIndex, count, timeUnit)
-  }
-
-  async timeDurationRate(
-    timeConfig: SingleTimeConfig,
-    startBlockNumber?: XL1BlockNumber,
-    timeUnit?: keyof TimeDurations,
-    toleranceMs?: number,
-    maxAttempts?: number,
-  ): Promise<BlockRate> {
-    return await calculateTimeRate(this, timeConfig, startBlockNumber, timeUnit, toleranceMs, maxAttempts)
-  }
-
-  protected getBlockContextRead(): BlockContextRead {
-    return {
-      ...this.context,
-      chainMap: this.store.chainMap,
-    }
-  }
-
-  protected async getChainContextRead(): Promise<ChainContextRead> {
-    return {
-      ...this.getBlockContextRead(),
-      head: (await this.finalizationViewer.head())[0],
-    }
-  }
-
-  private async blockByNumberWithContext(
-    chainContext: ChainContextRead,
-    blockNumber: XL1BlockNumber,
-  ): Promise<SignedHydratedBlockWithHashMeta | null> {
-    const block = asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(chainContext, blockNumber)) ?? null
-    const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []]
-    return result
-  }
-}

package/src/simple/block/index.ts

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