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

package/src/CreatableProvider/ProviderFactoryLocator.ts

@@ -1,170 +0,0 @@
-import { hasAllLabels, type Labels } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderContext } from '../model/index.ts'
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-import { type CreatableProviderRegistry, registerCreatableProviderFactory } from './CreatableProviderRegistry.ts'
-import type { ProviderFactoryGetInstanceOptions } from './GetInstanceOptions.ts'
-import { hasLabels, type LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-import type { ProviderFactoryLocatorInstance } from './ProviderFactoryLocatorInstance.ts'
-
-/**
- * A class which encapsulates the Service Locator Pattern for Provider Factories
- */
-export class ProviderFactoryLocator<TContext extends CreatableProviderContext = CreatableProviderContext,
-  TMonikers extends ProviderMoniker[] = ProviderMoniker[]> implements ProviderFactoryLocatorInstance<TContext> {
-  protected readonly _context: TContext
-  protected readonly _registry: CreatableProviderRegistry<TMonikers>
-
-  private _frozen = false
-  private _parent?: ProviderFactoryLocatorInstance<TContext>
-  private _validateDepsOnRegister: boolean
-
-  constructor(context: (Omit<TContext, 'locator'> & { locator?: TContext['locator'] }), registry: CreatableProviderRegistry = {}, validateDepsOnRegister = false) {
-    this._registry = registry
-    this._context = { ...context, locator: this } as unknown as TContext
-    this._parent = context.locator as ProviderFactoryLocatorInstance<TContext>
-    this._validateDepsOnRegister = validateDepsOnRegister
-  }
-
-  get context() {
-    return this._context
-  }
-
-  get logger() {
-    return this.context.logger
-  }
-
-  /**
-   * The current registry for the module factory
-   */
-  get registry(): Readonly<CreatableProviderRegistry> {
-    return this._registry
-  }
-
-  protected get validateDepsOnRegister() {
-    return this._validateDepsOnRegister
-  }
-
-  freeze() {
-    this._frozen = true
-  }
-
-  async getInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    { start = true, labels }: ProviderFactoryGetInstanceOptions = {},
-  ) {
-    return assertEx(
-      await this.tryGetInstance<TProvider>(moniker, { start, labels }),
-      () => `No provider instance for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ''} could be created`,
-    )
-  }
-
-  has(moniker: TMonikers[number]): boolean {
-    return !!this._registry[moniker]
-  }
-
-  /**
-   * Locates a provider factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the provider
-   * @param labels The labels for the provider factory
-   * @returns A provider factory that matches the supplied moniker and labels or throws if one is not found
-   */
-  locate<TProvider extends Provider<ProviderMoniker>>(moniker: TProvider['moniker'], labels?: Labels):
-    CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> {
-    return assertEx(
-      this.tryLocate<TProvider>(moniker, labels),
-
-      () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ''} registered`,
-    )
-  }
-
-  merge(locator: ProviderFactoryLocatorInstance): ProviderFactoryLocatorInstance {
-    const registry = { ...this.registry }
-    for (const moniker in locator.registry) {
-      if (registry[moniker]) {
-        registry[moniker].push(...(locator.registry[moniker] ?? []))
-      } else {
-        registry[moniker] = locator.registry[moniker]
-      }
-    }
-    return new ProviderFactoryLocator(this.context, registry)
-  }
-
-  /**
-   * Registers a single module factory (with optional tags) with the locator
-   * @param factory The factory to register
-   * @param labels The labels for the module factory
-   */
-  register(factory: CreatableProviderFactory, labels?: Labels, primary: boolean | ProviderMoniker | ProviderMoniker[] = false): this {
-    assertEx(!this._frozen, () => 'Cannot register a module factory after the locator has been frozen')
-    if (this.validateDepsOnRegister) {
-      const missingDeps = factory.dependencies.filter(dep => !this.registered(dep))
-      assertEx(missingDeps.length === 0, () => `Cannot register module factory [${factory.uniqueId.description}] due to missing dependencies: ${missingDeps.join(', ')}`)
-    }
-    registerCreatableProviderFactory(this._registry, factory, labels, primary)
-    return this
-  }
-
-  /**
-   * Registers multiple module factories with the locator
-   * @param factories The factories to register
-   */
-  registerMany(factories: CreatableProviderFactory[]): this {
-    for (const factory of factories) {
-      this.register(factory)
-    }
-    return this
-  }
-
-  registered(moniker: ProviderMoniker) {
-    return !!this.registry[moniker] || (this._parent?.registered(moniker) ?? false)
-  }
-
-  async tryGetInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    { start = true, labels }: ProviderFactoryGetInstanceOptions = {},
-  ) {
-    const resolvedParams = { context: this.context } as CreatableProviderInstance<TProvider>['params']
-    const factory = this.tryLocate<TProvider>(moniker, labels)
-    if (factory) {
-      if (this.context.singletons[factory.uniqueId]) {
-        return this.context.singletons[factory.uniqueId] as CreatableProviderInstance<TProvider>
-      }
-      this.logger?.info(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ''} using factory [${factory.uniqueId.description}]`)
-      const result = await factory.getInstance(resolvedParams, { start })
-      this.context.singletons[factory.uniqueId] = result
-      return result
-    }
-  }
-
-  /**
-   * Tries to locate a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or undefined
-   */
-  tryLocate<TProvider extends Provider<ProviderMoniker>>(moniker: TProvider['moniker'], labels?: Labels) {
-    const result = (labels
-      // Find the first factory that has labels and has all the labels provided
-      ? (this._registry[moniker]?.filter(hasLabels).find(factory => hasAllLabels(factory?.labels, labels)) ?? this._registry[moniker]?.[0])
-      // Otherwise, return the first factory
-      : this._registry[moniker]?.[0]) ?? this._parent?.tryLocate<TProvider>(moniker, labels)
-
-    return result as CreatableProviderFactory<CreatableProviderInstance<TProvider>>
-      | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-  }
-
-  validateDependencies(recursive = false) {
-    if (recursive) {
-      this._parent?.validateDependencies()
-    }
-    for (const moniker in this.registry) {
-      for (const factory of this.registry[moniker] ?? []) {
-        const missingDeps = factory.dependencies.filter(dep => !this.registered(dep))
-        assertEx(missingDeps.length === 0, () => `Module factory [${factory.uniqueId.description}] is missing dependencies: ${missingDeps.join(', ')}`)
-      }
-    }
-  }
-}

package/src/CreatableProvider/ProviderFactoryLocatorInstance.ts

@@ -1,70 +0,0 @@
-import type { Labels } from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderContext } from '../model/index.ts'
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-import type { CreatableProviderRegistry } from './CreatableProviderRegistry.ts'
-import type { ProviderFactoryGetInstanceOptions } from './GetInstanceOptions.ts'
-import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-
-/** Interface for ProviderFactoryLocator instances. */
-export interface ProviderFactoryLocatorInstance<T extends CreatableProviderContext = CreatableProviderContext> {
-
-  context: T
-
-  /**
-   * The current registry for the module factory
-   */
-  registry: Readonly<CreatableProviderRegistry>
-
-  freeze(): void
-
-  getInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    options?: ProviderFactoryGetInstanceOptions,
-  ): Promise<CreatableProviderInstance<TProvider>>
-
-  /**
-   * Locates a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or throws if one is not found
-   */
-  locate<TProvider extends Provider<ProviderMoniker>>(moniker: ProviderMoniker, labels?: Labels):
-    CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-
-  merge(locator: ProviderFactoryLocatorInstance): ProviderFactoryLocatorInstance
-
-  /**
-   * Registers a single module factory (with optional tags) with the locator
-   * @param factory The factory to register
-   * @param labels The labels for the module factory
-   */
-  register(factory: CreatableProviderFactory, labels?: Labels, primary?: boolean | ProviderMoniker | ProviderMoniker[]): ProviderFactoryLocatorInstance
-
-  /**
-   * Registers multiple module factories with the locator
-   * @param factories The factories to register
-   */
-  registerMany(factories: CreatableProviderFactory[]): ProviderFactoryLocatorInstance
-
-  registered(moniker: ProviderMoniker): boolean
-
-  tryGetInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    options?: ProviderFactoryGetInstanceOptions,
-  ): Promise<CreatableProviderInstance<TProvider> | undefined>
-
-  /**
-   * Tries to locate a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or undefined
-   */
-  tryLocate<TProvider extends Provider<ProviderMoniker>>(
-    moniker: ProviderMoniker,
-    labels?: Labels
-  ): CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-
-  validateDependencies(): void
-}

package/src/CreatableProvider/index.ts

@@ -1,8 +0,0 @@
-export * from './AbstractCreatableProvider.ts'
-export * from './CreatableProvider.ts'
-export * from './CreatableProviderRegistry.ts'
-export * from './GetInstanceOptions.ts'
-export * from './LabeledCreatableProviderFactory.ts'
-export * from './ProviderFactory.ts'
-export * from './ProviderFactoryLocator.ts'
-export * from './ProviderFactoryLocatorInstance.ts'

package/src/SignedBigInt.ts

@@ -1,59 +0,0 @@
-import {
-  type Hex,
-  hexToBigInt,
-  toHex,
-} from '@xylabs/sdk-js'
-import { isObject } from '@xylabs/sdk-js'
-
-/** Represents a negative bigint value stored as a hex string */
-export interface NegativeBigInt {
-  negative: Hex
-}
-
-/** Represents a positive bigint value stored as a hex string */
-export interface PositiveBigInt {
-  positive: Hex
-}
-
-/** A signed bigint value represented as either a negative or positive hex string */
-export type SignedBigInt = NegativeBigInt | PositiveBigInt
-
-/** Type guard that checks if a value is a NegativeBigInt */
-export const isNegativeBigInt = (value: unknown): value is NegativeBigInt => {
-  return isObject(value) && 'negative' in value && typeof value.negative === 'string'
-}
-
-/** Type guard that checks if a value is a PositiveBigInt */
-export const isPositiveBigInt = (value: unknown): value is PositiveBigInt => {
-  return isObject(value) && 'positive' in value && typeof value.positive === 'string'
-}
-
-/** parseSignedBigInt constant. */
-export const parseSignedBigInt = (value: SignedBigInt): bigint => {
-  if (isNegativeBigInt(value)) {
-    return -hexToBigInt(value.negative)
-  } else if (isPositiveBigInt(value)) {
-    return hexToBigInt(value.positive)
-  } else {
-    throw new Error('Invalid balance type')
-  }
-}
-
-/** toSignedBigInt constant. */
-export const toSignedBigInt = (value: bigint): SignedBigInt => {
-  return value < 0n ? { negative: toHex(-value) } : { positive: toHex(value) }
-}
-
-/** toPositiveBigInt constant. */
-export const toPositiveBigInt = (value: unknown): PositiveBigInt => {
-  if (isNegativeBigInt(value)) {
-    return { positive: toHex(0n) }
-  }
-  if (isPositiveBigInt(value)) {
-    return { positive: value.positive }
-  }
-  if (typeof value === 'bigint') {
-    return { positive: toHex(value) }
-  }
-  throw new Error('Invalid value for positive big int')
-}

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()
-  }
-}