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

package/src/_internal/context/getTestProviderContext.ts

@@ -1,13 +0,0 @@
-import type { Config } from '../../config/index.ts'
-import { ProviderFactoryLocator } from '../../CreatableProvider/index.ts'
-import type { CreatableProviderContext } from '../../model/index.ts'
-
-// This file should not be exported from the package
-export function getTestProviderContext(config: Config): CreatableProviderContext {
-  const singletons = {}
-  const caches = {}
-  const locator = new ProviderFactoryLocator({
-    config, singletons, caches, logger: console,
-  })
-  return locator.context
-}

package/src/_internal/context/index.ts

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

package/src/_internal/index.ts

@@ -1,2 +0,0 @@
-// _internal should never be exported from public barrel
-export * from './context/index.ts'

package/src/actor/ActorV3.ts

@@ -1,177 +0,0 @@
-import type {
-  CreatableInstance, CreatableName, CreatableParams, CreatableStatusReporter, EmptyObject,
-  Logger,
-} from '@xylabs/sdk-js'
-import {
-  AbstractCreatable,
-  assertEx,
-  delay, IdLogger,
-} from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import { Semaphore } from 'async-mutex'
-import z from 'zod'
-
-import type { ProviderFactoryLocatorInstance } from '../CreatableProvider/index.ts'
-
-const CreatableNameZod = z.custom<CreatableName>(val => typeof val === 'string' && val.length > 0)
-const StatusReporterInstanceZod = z.custom<CreatableStatusReporter>(val => val && typeof val === 'object' && 'report' in val)
-const AccountInstanceZod = z.custom<AccountInstance>(val => val && typeof val === 'object' && 'address' in val)
-
-/** ActorParamsV3Zod constant. */
-export const ActorParamsV3Zod = z.object({
-  account: AccountInstanceZod,
-  locator: z.unknown(),
-  name: CreatableNameZod,
-  statusReporter: StatusReporterInstanceZod.optional(),
-})
-
-/** ActorParamsV3Zod type. */
-export type ActorParamsV3Zod = z.infer<typeof ActorParamsV3Zod>
-
-/** ActorParamsV3 type. */
-export type ActorParamsV3<T extends EmptyObject | void = void> = CreatableParams & {
-  account: AccountInstance
-  locator: ProviderFactoryLocatorInstance
-} & (T extends void ? EmptyObject : T)
-
-/** ActorInstanceV3 type. */
-export type ActorInstanceV3<T extends ActorParamsV3 = ActorParamsV3> = CreatableInstance<T>
-
-/** ActorV3 implementation. */
-export abstract class ActorV3<TParams extends ActorParamsV3 = ActorParamsV3> extends AbstractCreatable<TParams> {
-  protected readonly _intervals: Map<string, ReturnType<typeof setInterval>> = new Map()
-  protected readonly _semaphores: Map<string, Semaphore> = new Map()
-  protected readonly _timeouts: Map<string, ReturnType<typeof setTimeout>> = new Map()
-
-  private _logger?: Logger
-
-  override get logger() {
-    this._logger = new IdLogger(assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`), () => this.name)
-    return this._logger
-  }
-
-  protected get account() {
-    return this.params.account
-  }
-
-  protected get context() {
-    return this.locator.context
-  }
-
-  protected get locator() {
-    return this.params.locator
-  }
-
-  static override async paramsHandler<T extends ActorInstanceV3>(params: Partial<T['params']>) {
-    const baseParams = await super.paramsHandler({ ...params, name: params.name ?? 'UnknownActor' })
-    const account = assertEx(params.account, () => `params.account is required for actor ${baseParams.name}.`)
-    const locator = assertEx(params.locator, () => `params.locator is required for actor ${baseParams.name}.`)
-    return {
-      ...baseParams, account, locator,
-    } satisfies ActorParamsV3
-  }
-
-  /**
-   * The timer runs until the actor is deactivated (or you manually stop it).
-   */
-  registerTimer(timerName: string, callback: () => Promise<void>, dueTimeMs: number, periodMs: number) {
-    if (this.status !== 'starting') {
-      this.logger?.warn(
-        `Cannot register timer '${timerName}' because actor is not starting.`,
-      )
-      return
-    }
-
-    let running = false
-
-    this._semaphores.set(timerName, new Semaphore(1))
-
-    const timeoutId = setTimeout(() => {
-      const intervalId = setInterval(() => {
-        const semaphore = this._semaphores.get(timerName)
-        if (this.status !== 'started' || !this._intervals.has(timerName) || !semaphore || running) return
-        if (semaphore.isLocked()) {
-          this.logger?.warn(
-            `Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`,
-          )
-          return
-        }
-        semaphore.acquire().then(([, release]) => {
-          const startTime = Date.now()
-          running = true
-          callback()
-            .then(() => {
-              const duration = Date.now() - startTime
-              if (duration > periodMs) {
-                this.logger?.warn(
-                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`,
-                )
-              } else if (duration > 5000) {
-                this.logger?.warn(
-                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`,
-                )
-              }
-            })
-            .catch((error) => {
-              this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`)
-              this.logger?.error(error.stack)
-            })
-            .finally(() => {
-              release()
-              running = false
-            })
-        }).catch((error) => {
-          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${error}`)
-        })
-      }, periodMs)
-
-      // store interval so we can clear it on stop()
-      this._intervals.set(timerName, intervalId)
-    }, dueTimeMs)
-
-    // store timeout so we can clear it on stop() if interval hasn't started yet
-    this._timeouts.set(timerName, timeoutId)
-
-    this.logger?.log(
-      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`,
-    )
-  }
-
-  /**
-   * Called by the Orchestrator when the actor is deactivated.
-   * Stop all running timers.
-   */
-  override async stopHandler() {
-    await super.stopHandler()
-    this.logger?.log('Stopping all timers...')
-
-    // wait for all semaphores to be free and acquire them to prevent new tasks from starting
-    await Promise.all(
-      [...this._semaphores.values()].map(async (semaphore) => {
-        // Wait for any running tasks to complete
-        while (semaphore.isLocked()) {
-          this.logger?.log('Waiting for running timer task to complete...')
-          await delay(500)
-        }
-        await semaphore.acquire()
-      }),
-    )
-
-    this._semaphores.clear()
-
-    for (const [, timeoutRef] of this._timeouts.entries()) {
-      clearTimeout(timeoutRef)
-    }
-    this._timeouts.clear()
-
-    for (const [, intervalRef] of this._intervals.entries()) {
-      clearInterval(intervalRef)
-    }
-    this._intervals.clear()
-
-    this.logger?.log('Stopped.')
-  }
-}
-
-/** Actor implementation. */
-export abstract class Actor<TParams extends ActorParamsV3 = ActorParamsV3> extends ActorV3<TParams> {}

package/src/actor/index.ts

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

package/src/amount/ShiftedBigInt.ts

@@ -1,73 +0,0 @@
-import type { ShiftedBigIntConfig } from '@xyo-network/xl1-protocol-lib'
-
-import { splitOnDecimalToString } from './splitOnDecimalToString.ts'
-
-/** Represents a bigint with a fixed decimal point shift, supporting locale-aware string formatting */
-export class ShiftedBigInt {
-  static readonly defaultConfig: ShiftedBigIntConfig = {
-    places: 18,
-    maxDecimal: 18,
-    maxCharacters: 9,
-    minDecimals: 1,
-    locale: 'en-US',
-  }
-
-  config: ShiftedBigIntConfig
-  value: bigint
-
-  constructor(
-    value: bigint | ShiftedBigInt,
-    config: Partial<ShiftedBigIntConfig> = {},
-  ) {
-    this.value = typeof value === 'bigint' ? value : value.value
-    this.config = {
-      ...ShiftedBigInt.defaultConfig, ...(typeof value === 'bigint' ? {} : value.config), ...config,
-    }
-  }
-
-  get locale(): Intl.LocalesArgument {
-    return this.config.locale ?? 'en-US'
-  }
-
-  get maxCharacters(): number {
-    return this.config.maxCharacters ?? 9
-  }
-
-  get maxDecimal(): number {
-    return this.config.maxDecimal ?? this.places
-  }
-
-  get minDecimals(): number {
-    return this.config.minDecimals ?? 1
-  }
-
-  get places(): number {
-    return this.config.places ?? 18
-  }
-
-  toFullString(): string {
-    return splitOnDecimalToString(
-      this.value,
-      this.places,
-      this.places,
-      Infinity,
-      this.places,
-      this.locale,
-    )
-  }
-
-  toShortString(): string {
-    return splitOnDecimalToString(
-      this.value,
-      this.places,
-      this.maxDecimal,
-      this.maxCharacters,
-      this.minDecimals,
-      this.locale,
-    )
-  }
-
-  toString(): string {
-    return this.toFullString()
-  }
-}

package/src/amount/XL1Amount.ts

@@ -1,103 +0,0 @@
-/* eslint-disable @typescript-eslint/member-ordering */
-import { assertEx } from '@xylabs/sdk-js'
-import type { ShiftedBigIntConfig, XL1AmountInstance } from '@xyo-network/xl1-protocol-lib'
-import {
-  AttoXL1, FemtoXL1, MicroXL1, MilliXL1, NanoXL1, PicoXL1, XL1,
-  XL1Places,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { ShiftedBigInt } from './ShiftedBigInt.ts'
-
-const MAX_XL1_AMOUNT = 2n ** 256n - 1n
-const allowedPlaces = Object.values(XL1Places)
-
-/** Represents an XL1 token amount stored in AttoXL1, with conversions to milli, micro, nano, pico, femto, and atto denominations */
-export class XL1Amount implements XL1AmountInstance {
-  value: AttoXL1
-  private locale: Intl.LocalesArgument
-
-  constructor(value: bigint, locale: Intl.LocalesArgument = 'en-US') {
-    this.locale = locale
-    this.value = AttoXL1(value > MAX_XL1_AMOUNT ? MAX_XL1_AMOUNT : value < 0n ? 0n : value)
-  }
-
-  static from(value: bigint, places: bigint = XL1Places.atto) {
-    assertEx(allowedPlaces.includes(places), () => `Invalid conversion places (${places} not in ${allowedPlaces})`)
-    return new XL1Amount(value * 10n ** BigInt(places))
-  }
-
-  static fromMilli(value: MilliXL1) {
-    return this.from(value, XL1Places.milli)
-  }
-
-  static fromMicro(value: MicroXL1) {
-    return this.from(value, XL1Places.micro)
-  }
-
-  static fromNano(value: NanoXL1) {
-    return this.from(value, XL1Places.nano)
-  }
-
-  static fromPico(value: PicoXL1) {
-    return this.from(value, XL1Places.pico)
-  }
-
-  static fromFemto(value: FemtoXL1) {
-    return this.from(value, XL1Places.femto)
-  }
-
-  static fromAtto(value: AttoXL1) {
-    return this.from(value, XL1Places.atto)
-  }
-
-  static fromXL1(value: XL1) {
-    return this.from(value, XL1Places.xl1)
-  }
-
-  to(places: number | bigint = XL1Places.atto) {
-    return this.value / 10n ** BigInt(places)
-  }
-
-  get milli() {
-    return MilliXL1(this.to(XL1Places.milli))
-  }
-
-  get micro() {
-    return MicroXL1(this.to(XL1Places.micro))
-  }
-
-  get nano() {
-    return NanoXL1(this.to(XL1Places.nano))
-  }
-
-  get pico() {
-    return PicoXL1(this.to(XL1Places.pico))
-  }
-
-  get femto() {
-    return FemtoXL1(this.to(XL1Places.femto))
-  }
-
-  get atto() {
-    return AttoXL1(this.to(XL1Places.atto))
-  }
-
-  get xl1() {
-    return XL1(this.to(XL1Places.xl1))
-  }
-
-  toString(places: number = Number(XL1Places.atto), config: Partial<ShiftedBigIntConfig> = {}): string {
-    assertEx(allowedPlaces.includes(BigInt(places)), () => `Invalid conversion places (${places} not in ${allowedPlaces})`)
-    return new ShiftedBigInt(
-      this.value,
-      {
-        places,
-        locale: this.locale,
-        maxDecimal: places,
-        minDecimals: 0,
-        maxCharacters: places,
-        ...config,
-      },
-    ).toShortString()
-  }
-}

package/src/amount/index.ts

@@ -1,4 +0,0 @@
-export * from './ShiftedBigInt.ts'
-export * from './splitOnDecimal.ts'
-export * from './splitOnDecimalToString.ts'
-export * from './XL1Amount.ts'

package/src/amount/splitOnDecimal.ts

@@ -1,6 +0,0 @@
-/** Splits a bigint into whole and decimal parts based on the specified number of decimal places */
-export const splitOnDecimal = (value: bigint, places = 18): [bigint, bigint] => {
-  const whole = value / BigInt(10 ** places)
-  const decimal = value % BigInt(10 ** places)
-  return [whole, decimal]
-}

package/src/amount/splitOnDecimalToString.ts

@@ -1,40 +0,0 @@
-import { splitOnDecimal } from './splitOnDecimal.ts'
-
-/** Formats a bigint as a locale-aware decimal string with configurable precision and character limits */
-export const splitOnDecimalToString = (
-  value: bigint,
-  places = 18,
-  maxDecimal = places,
-  maxCharacters = 9,
-  minDecimals = 1,
-  locale: Intl.LocalesArgument = 'en-US',
-): string => {
-  const [whole, decimal] = splitOnDecimal(value, places)
-  const remainderLength = decimal.toString().length
-  const precedingZerosInDecimal = places - remainderLength
-  if (whole === 0n && precedingZerosInDecimal >= maxDecimal && decimal !== 0n) return '< 0.'.padEnd(maxDecimal + 5, '0') + '1'
-
-  const wholeCharacters = whole.toString(10).length
-  const calcMaxDecimalCharacters = maxCharacters === -1 ? places : wholeCharacters > maxCharacters ? 0 : maxCharacters - wholeCharacters
-  const maxDecimalCharacters = Math.min(maxDecimal, calcMaxDecimalCharacters)
-
-  // Format whole number with thousand separators according to locale
-  const formattedWhole = new Intl.NumberFormat(locale, {
-    maximumFractionDigits: 0,
-    useGrouping: true,
-  }).format(whole)
-
-  // Get decimal separator for the locale
-  const decimalSeparator = new Intl.NumberFormat(locale)
-    .formatToParts(1.1)
-    .find(part => part.type === 'decimal')?.value ?? '.'
-
-  // Pad decimal part to correct number of places
-  let paddedDecimal = decimal.toString().padStart(places, '0').slice(0, maxDecimalCharacters)
-  // remove unneeded trailing zeros (honoring minDecimals)
-  while (paddedDecimal.length > minDecimals && paddedDecimal.endsWith('0')) {
-    paddedDecimal = paddedDecimal.slice(0, -1)
-  }
-
-  return `${formattedWhole}${paddedDecimal.length > 0 ? decimalSeparator : ''}${paddedDecimal}`
-}

package/src/block/hydrate/allHashesPresent.ts

@@ -1,8 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { Payload, WithHashMeta } from '@xyo-network/sdk-js'
-
-/** AllHashesPresent helper function. */
-export function allHashesPresent(hashes: Hash[], payloads: WithHashMeta<Payload>[]): boolean {
-  const payloadHashes = new Set(payloads.map(p => p._hash))
-  return hashes.every(hash => payloadHashes.has(hash))
-}

package/src/block/hydrate/blockPayloadsFromHydratedBlock.ts

@@ -1,12 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { WithStorageMeta } from '@xyo-network/sdk-js'
-import type { HydratedBlockWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-import { isTransactionBoundWitness } from '@xyo-network/xl1-protocol-lib'
-
-/** blockPayloadsFromHydratedBlock constant. */
-export const blockPayloadsFromHydratedBlock = (block: HydratedBlockWithStorageMeta): WithStorageMeta[] => {
-  return block[0].payload_hashes.map(hash => assertEx(
-    block[1].find(p => p._hash === hash),
-    () => `missing payload ${hash}`,
-  )).filter(x => !isTransactionBoundWitness(x))
-}

package/src/block/hydrate/flattenHydratedBlock.ts

@@ -1,28 +0,0 @@
-import type { Payload } from '@xyo-network/sdk-js'
-import { type BlockBoundWitness, toHydratedBlock } from '@xyo-network/xl1-protocol-lib'
-
-/** flattenHydratedBlock constant. */
-export const flattenHydratedBlock = <B extends BlockBoundWitness, P extends Payload>(hydratedBlock: [B, P[]]): (P | B)[] => {
-  const [blk, blkPayloads] = hydratedBlock
-  return [...blkPayloads, blk]
-}
-
-/** tryUnflattenHydratedBlock constant. */
-export const tryUnflattenHydratedBlock = <
-  B extends BlockBoundWitness,
-  P extends Payload,
->(flattened: (P | B)[]): [B, P[]] | undefined => {
-  // Last element is the block
-  const blk = flattened.at(-1) as B
-
-  // All previous elements are payloads
-  const payloads = flattened.slice(0, -1) as P[]
-
-  return toHydratedBlock([blk, payloads])
-}
-
-/** unflattenHydratedBlock constant. */
-export const unflattenHydratedBlock = <
-  B extends BlockBoundWitness,
-  P extends Payload,
->(flattened: (P | B)[]): [B, P[]] => toHydratedBlock(tryUnflattenHydratedBlock(flattened), true) as [B, P[]]

package/src/block/hydrate/flattenHydratedBlocks.ts

@@ -1,7 +0,0 @@
-import type { HydratedBlock } from '@xyo-network/xl1-protocol-lib'
-
-import { flattenHydratedBlock } from './flattenHydratedBlock.ts'
-
-/** flattenHydratedBlocks constant. */
-export const flattenHydratedBlocks = <T extends HydratedBlock>(hydratedBlocks: T[]): (T[0] | T[1][number])[] =>
-  hydratedBlocks.flatMap(blk => flattenHydratedBlock(blk))

package/src/block/hydrate/hydrateBlock.ts

@@ -1,43 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import { asAnyPayload } from '@xyo-network/sdk-js'
-import type { BlockContextRead, HydratedBlockWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-
-import { allHashesPresent } from './allHashesPresent.ts'
-
-/** hydrateBlock constant. */
-export const hydrateBlock = async (
-  context: BlockContextRead,
-  hash: Hash,
-  maxDepth: number = 1,
-  minDepth = maxDepth,
-): Promise<HydratedBlockWithStorageMeta> => {
-  assertEx(maxDepth >= 0, () => 'maxDepth must be greater than or equal to 0')
-  assertEx(minDepth >= 0, () => 'minDepth must be greater than or equal to 0')
-  assertEx(maxDepth >= minDepth, () => 'maxDepth must be greater than or equal to minDepth')
-
-  const { chainMap } = context
-
-  const [block] = await chainMap.get([hash])
-  const bw = assertEx(asBlockBoundWitnessWithStorageMeta(
-    assertEx(block, () => `block ${hash} not found`),
-  ), () => `hash ${hash} is not a BlockBoundWitness`)
-
-  if (maxDepth === 0) return [bw, []]
-  const blkPayloads = (await chainMap.get(bw.payload_hashes)).map(p => asAnyPayload(p, true))
-  if (minDepth === 1) assertEx(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`)
-  if (maxDepth === 1) return [bw, blkPayloads]
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta)
-  const transactionsPayloadHashes = transactions.flatMap(tx => tx.payload_hashes)
-  const transactionsPayloads = (await chainMap.get(transactionsPayloadHashes)).map(p => asAnyPayload(p, true))
-  assertEx(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`)
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap(p => p._hash))
-  const allPayloads = (await chainMap.get([...allPayloadsHashes])).map(p => asAnyPayload(p, true))
-  const allPayloadsFiltered = allPayloads.filter(p => allPayloadsHashes.has(p._hash))
-  if (maxDepth === 2) assertEx(allHashesPresent(
-    [...allPayloadsHashes],
-    allPayloadsFiltered,
-  ), () => `Unable to find all payloads for transactions in block ${hash}`)
-  return [bw, allPayloadsFiltered]
-}

package/src/block/hydrate/index.ts

@@ -1,7 +0,0 @@
-export * from './allHashesPresent.ts'
-export * from './blockPayloadsFromHydratedBlock.ts'
-export * from './flattenHydratedBlock.ts'
-export * from './flattenHydratedBlocks.ts'
-export * from './hydrateBlock.ts'
-export * from './transactionsFromHydratedBlock.ts'
-export * from './tryHydrateBlock.ts'

package/src/block/hydrate/transactionsFromHydratedBlock.ts

@@ -1,7 +0,0 @@
-import type { HydratedBlock, TransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-import { isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-
-/** transactionsFromHydratedBlock constant. */
-export const transactionsFromHydratedBlock = (block: HydratedBlock): TransactionBoundWitnessWithStorageMeta[] => {
-  return block[1].filter(isTransactionBoundWitnessWithStorageMeta)
-}

package/src/block/hydrate/tryHydrateBlock.ts

@@ -1,26 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { ReadArchivist } from '@xyo-network/sdk-js'
-import type { HydratedBlock } from '@xyo-network/xl1-protocol-lib'
-import { isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-
-/** tryHydrateBlock constant. */
-export const tryHydrateBlock = async (
-  archivist: ReadArchivist,
-  hash: Hash,
-  maxDepth: number = 1,
-): Promise<HydratedBlock | undefined> => {
-  assertEx(maxDepth >= 0, () => 'maxDepth must be greater than or equal to 0')
-  const bw = (await archivist.get([hash])).find(isBlockBoundWitnessWithStorageMeta)
-  if (!bw) return undefined
-  if (maxDepth === 0) return [bw, []]
-  const blkPayloads = await archivist.get(bw.payload_hashes)
-  if (maxDepth === 1) return [bw, blkPayloads]
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta)
-  const transactionsPayloadHashes = transactions.flatMap(tx => tx.payload_hashes)
-  const transactionsPayloads = await archivist.get(transactionsPayloadHashes)
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap(p => p._hash))
-  const allPayloads = await archivist.get([...allPayloadsHashes])
-  const allPayloadsFiltered = allPayloads.filter(p => allPayloadsHashes.has(p._hash))
-  return [bw, allPayloadsFiltered]
-}

package/src/block/index.ts

@@ -1,2 +0,0 @@
-export * from './hydrate/index.ts'
-export * from './primitives/index.ts'

package/src/block/primitives/blockFromBlockNumber.ts

@@ -1,69 +0,0 @@
-import {
-  asHash, type Hash, isDefined,
-  spanAsync,
-} from '@xylabs/sdk-js'
-import { toSafeJsonString } from '@xylabs/sdk-js'
-import type { Signed, WithHashMeta } from '@xyo-network/sdk-js'
-import type {
-  BlockBoundWitness, ChainContextRead, XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asSignedBlockBoundWitnessWithStorageMeta, SignedBlockBoundWitnessWithHashMetaZod, StepSizes,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { withContextCacheResponse } from '../../ChainContextHelpers.ts'
-
-/** BlockFromBlockNumber helper function. */
-export async function blockFromBlockNumber(
-  context: ChainContextRead,
-  blockNumber: XL1BlockNumber,
-): Promise<WithHashMeta<Signed<BlockBoundWitness>>> {
-  return await spanAsync('blockFromBlockNumber', async () => {
-    const cacheKey = `${blockNumber}`
-    const { chainMap, head } = context
-    return await withContextCacheResponse(context, 'blockFromBlockNumber', cacheKey, async () => {
-      const [result] = await chainMap.get([head._hash])
-      if (!isDefined(result)) {
-        throw new Error(`Head block not found for hash: ${head._hash}`)
-      }
-      let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
-        result,
-        () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`,
-      )
-      if (currentBlock.block < blockNumber) {
-        throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`)
-      }
-      while (currentBlock.block > blockNumber) {
-        let jumpHash: Hash | null = currentBlock.previous
-        let jumpBlockNumber = currentBlock.block - 1
-        for (const [step, stepSize] of StepSizes.entries()) {
-          const possibleJumpBlockNumber = currentBlock.block - (currentBlock.block % stepSize) - 1
-          if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
-            jumpBlockNumber = possibleJumpBlockNumber
-            jumpHash = asHash(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`)
-          }
-        }
-        const [newBlock] = await chainMap.get([
-          asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`),
-        ])
-        if (!isDefined(newBlock)) {
-          throw new Error(`Block not found for jump hash: ${jumpHash}`)
-        }
-        currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
-          newBlock,
-          () => {
-            const result = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock)
-            return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result.error}`
-          },
-        )
-        if (currentBlock.block === blockNumber) {
-          break
-        }
-        if (currentBlock.block < blockNumber) {
-          throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${head._hash}.`)
-        }
-      }
-      return currentBlock
-    })
-  }, { ...context, timeBudgetLimit: 500 })
-}