@xyo-network/xl1-protocol 1.25.33 → 1.26.1

package/src/viewers/TransactionInvalidation.ts

@@ -1,70 +0,0 @@
-import { type Promisable } from '@xylabs/sdk-js'
-import { zodIsFactory } from '@xylabs/sdk-js'
-import { z } from 'zod'
-
-import type { SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta } from '../model/index.ts'
-import {
-  ChainQualificationZod, ChainQualifiedHeadConfigZod, ChainQualifiedRangeConfigZod,
-} from '../model/index.ts'
-import type { Provider } from '../provider/index.ts'
-import type { HydratedTransactionValidationError } from '../validation/index.ts'
-
-/** TransactionInvalidationQualificationZod constant. */
-export const TransactionInvalidationQualificationZod = ChainQualificationZod
-/** TransactionInvalidationQualification type. */
-export type TransactionInvalidationQualification = z.infer<typeof TransactionInvalidationQualificationZod>
-/** Type guard that checks if a value is a valid TransactionInvalidationQualification. */
-export const isTransactionInvalidationQualification = zodIsFactory(TransactionInvalidationQualificationZod)
-
-/** TransactionInvalidationConfigFieldsZod constant. */
-export const TransactionInvalidationConfigFieldsZod = z.object({
-  state: z.boolean().optional(),
-  value: z.boolean().optional(),
-})
-
-/** TransactionInvalidationConfigZod constant. */
-export const TransactionInvalidationConfigZod = z.union([
-  TransactionInvalidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
-  TransactionInvalidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
-  TransactionInvalidationConfigFieldsZod,
-  z.object({}),
-])
-
-/** TransactionInvalidationConfig type. */
-export type TransactionInvalidationConfig = z.infer<typeof TransactionInvalidationConfigZod>
-/** Type guard that checks if a value is a valid TransactionInvalidationConfig. */
-export const isTransactionInvalidationConfig = zodIsFactory(TransactionInvalidationConfigZod)
-
-/**
- * Checks if transactions are invalid (impossible to ever become valid) according to protocol rules.
- */
-
-export interface TransactionInvalidationViewerMethods {
-  qualifiedInvalidateTransactions(
-    blocks: SignedHydratedTransaction[],
-    config?: TransactionInvalidationConfig
-  ): Promisable<[(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[], TransactionInvalidationQualification]>
-}
-
-/** Moniker identifier for the TransactionInvalidationViewer provider. */
-export const TransactionInvalidationViewerMoniker = 'TransactionInvalidationViewer' as const
-/** Type literal for the TransactionInvalidationViewer provider moniker. */
-export type TransactionInvalidationViewerMoniker = typeof TransactionInvalidationViewerMoniker
-
-/** Viewer interface for reading TransactionInvalidation data. */
-export interface TransactionInvalidationViewer extends TransactionInvalidationViewerMethods, Provider<TransactionInvalidationViewerMoniker> {
-  invalidateTransaction(
-    block: SignedHydratedTransaction,
-    config?: TransactionInvalidationConfig
-  ): Promisable<HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta>
-
-  invalidateTransactions(
-    blocks: SignedHydratedTransaction[],
-    config?: TransactionInvalidationConfig
-  ): Promisable<(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[]>
-
-  qualifiedInvalidateTransaction(
-    block: SignedHydratedTransaction,
-    config?: TransactionInvalidationConfig
-  ): Promisable<[HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta, TransactionInvalidationQualification]>
-}

package/src/viewers/TransactionValidation.ts

@@ -1,71 +0,0 @@
-import { type Promisable } from '@xylabs/sdk-js'
-import { zodIsFactory } from '@xylabs/sdk-js'
-import { z } from 'zod'
-
-import type { SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta } from '../model/index.ts'
-import {
-  ChainQualificationZod, ChainQualifiedHeadConfigZod, ChainQualifiedRangeConfigZod,
-} from '../model/index.ts'
-import type { Provider } from '../provider/index.ts'
-import type { HydratedTransactionValidationError } from '../validation/index.ts'
-
-/** TransactionValidationQualificationZod constant. */
-export const TransactionValidationQualificationZod = ChainQualificationZod
-/** TransactionValidationQualification type. */
-export type TransactionValidationQualification = z.infer<typeof TransactionValidationQualificationZod>
-/** Type guard that checks if a value is a valid TransactionValidationQualification. */
-export const isTransactionValidationQualification = zodIsFactory(TransactionValidationQualificationZod)
-
-/** TransactionValidationConfigFieldsZod constant. */
-export const TransactionValidationConfigFieldsZod = z.object({
-  value: z.boolean().optional(),
-  state: z.boolean().optional(),
-})
-
-/** TransactionValidationConfigZod constant. */
-export const TransactionValidationConfigZod = z.union([
-  TransactionValidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
-  TransactionValidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
-  TransactionValidationConfigFieldsZod,
-  z.object({}),
-])
-
-/** TransactionValidationConfig type. */
-export type TransactionValidationConfig = z.infer<typeof TransactionValidationConfigZod>
-/** Type guard that checks if a value is a valid TransactionValidationConfig. */
-export const isTransactionValidationConfig = zodIsFactory(TransactionValidationConfigZod)
-
-/** TransactionValidationViewerMethods interface. */
-export interface TransactionValidationViewerMethods {
-  qualifiedValidateTransactions(
-    blocks: SignedHydratedTransaction[],
-    config?: TransactionValidationConfig
-  ): Promisable<[(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[], TransactionValidationQualification]>
-}
-
-/** Moniker identifier for the TransactionValidationViewer provider. */
-export const TransactionValidationViewerMoniker = 'TransactionValidationViewer' as const
-/** Type literal for the TransactionValidationViewer provider moniker. */
-export type TransactionValidationViewerMoniker = typeof TransactionValidationViewerMoniker
-
-/**
- * Checks if transactions are valid (currently valid) according to protocol rules.
- * In the case that they are not valid, they may still become valid in the future.
- */
-
-export interface TransactionValidationViewer extends TransactionValidationViewerMethods, Provider<TransactionValidationViewerMoniker> {
-  qualifiedValidateTransaction(
-    block: SignedHydratedTransaction,
-    config?: TransactionValidationConfig
-  ): Promisable<[HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta, TransactionValidationQualification]>
-
-  validateTransaction(
-    block: SignedHydratedTransaction,
-    config?: TransactionValidationConfig
-  ): Promisable<HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta>
-
-  validateTransactions(
-    blocks: SignedHydratedTransaction[],
-    config?: TransactionValidationConfig
-  ): Promisable<(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[]>
-}

package/src/viewers/TransferBalance.ts

@@ -1,39 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import type { Signed } from '@xyo-network/sdk-js'
-
-import type { BlockBoundWitness } from '../block/index.ts'
-import type { XL1BlockRange } from '../model/index.ts'
-import type { Provider } from '../provider/index.ts'
-import type { TransactionBoundWitness } from '../transaction/index.ts'
-import type { Transfer } from '../TransferPayload.ts'
-import type { AttoXL1 } from '../xl1/index.ts'
-
-/** TransferBalanceHistoryItem type. */
-export type TransferBalanceHistoryItem = [
-  Signed<BlockBoundWitness> /* block */,
-  Signed<TransactionBoundWitness> | null,
-  Transfer, /* the actual transfer payload */
-]
-/** TransferPair type. */
-export type TransferPair = [Address, Address]
-
-/** TransferBalancesViewerMethods interface. */
-export interface TransferBalancesViewerMethods {
-  transferBalances(address: Address[]): Promisable<Partial<Record<Address, Record<Address, AttoXL1>>>>
-  transferBalancesHistories(address: Address[]): Promisable<Partial<Record<Address, Record<Address, TransferBalanceHistoryItem[]>>>>
-  transferPairBalances(address: TransferPair[]): Promisable<Partial<Record<Address, Record<Address, AttoXL1>>>>
-  transferPairBalancesHistories(address: TransferPair[]): Promisable<Partial<Record<Address, Record<Address, TransferBalanceHistoryItem[]>>>>
-}
-
-/** Moniker identifier for the TransferBalanceViewer provider. */
-export const TransferBalanceViewerMoniker = 'TransferBalanceViewer' as const
-/** Type literal for the TransferBalanceViewer provider moniker. */
-export type TransferBalanceViewerMoniker = typeof TransferBalanceViewerMoniker
-
-/** Viewer interface for reading TransferBalance data. */
-export interface TransferBalanceViewer extends TransferBalancesViewerMethods, Provider<TransferBalanceViewerMoniker> {
-  transferBalance(address: Address): Promisable<AttoXL1>
-  transferBalanceHistory(address: Address, range?: XL1BlockRange): Promisable<TransferBalanceHistoryItem[]>
-  transferPairBalance(address: TransferPair): Promisable<AttoXL1>
-  transferPairBalanceHistory(address: TransferPair): Promisable<TransferBalanceHistoryItem[]>
-}

package/src/viewers/WindowedBlock.ts

@@ -1,22 +0,0 @@
-import type { Hash, Promisable } from '@xylabs/sdk-js'
-
-import type { HydratedBlockWithHashMeta } from '../block/index.ts'
-import type { Provider, ProviderMoniker } from '../provider/index.ts'
-import type { BlockViewerMethods } from './Block.ts'
-
-type ExtendableBlockViewerMethods = Omit<BlockViewerMethods, 'rate' | 'stepSizeRate' | 'timeDurationRate'>
-
-/** WindowedBlockViewerMethods interface. */
-export interface WindowedBlockViewerMethods extends ExtendableBlockViewerMethods {
-  blocksByTransactionHashes(hashes: Hash[]): Promisable<HydratedBlockWithHashMeta[]>
-}
-
-/** Moniker identifier for the WindowedBlockViewer provider. */
-export const WindowedBlockViewerMoniker = 'WindowedBlockViewer' as const
-/** Type literal for the WindowedBlockViewer provider moniker. */
-export type WindowedBlockViewerMoniker = typeof WindowedBlockViewerMoniker
-
-/** Viewer interface for reading WindowedBlock data. */
-export interface WindowedBlockViewer<TMoniker extends ProviderMoniker = WindowedBlockViewerMoniker> extends WindowedBlockViewerMethods, Provider<TMoniker> {
-  blockByTransactionHash(hash: Hash): Promisable<HydratedBlockWithHashMeta | null>
-}

package/src/viewers/XyoViewer.ts

@@ -1,74 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-
-import type {
-  AccountBalanceHistoryItem, AccountBalanceViewer, ChainQualifiedConfig,
-} from '../model/index.ts'
-import type { Provider } from '../provider/index.ts'
-import type { AttoXL1 } from '../xl1/index.ts'
-import type { BlockViewer, BlockViewerMethods } from './Block.ts'
-import type { FinalizationViewer } from './Finalization.ts'
-import type { ForkViewerMethods } from './Fork.ts'
-import type { MempoolViewer } from './Mempool.ts'
-import type { NetworkStakeViewer } from './NetworkStake/index.ts'
-import type { NetworkStakeStepRewardViewerMethods } from './NetworkStakeStepReward.ts'
-import type { StakeViewer, StakeViewerMethods } from './Stake.ts'
-import type { StepViewer } from './StepViewer.ts'
-import type { TimeSyncViewer } from './TimeSync.ts'
-import type { TransactionViewer, TransactionViewerMethods } from './Transaction.ts'
-
-/** XyoViewerMethods interface. */
-export interface XyoViewerMethods extends
-  NetworkStakeStepRewardViewerMethods, BlockViewerMethods,
-  Omit<TransactionViewerMethods, 'byHash'>, Omit<
-    StakeViewerMethods, 'minWithdrawalBlocks' | 'rewardsContract' | 'stakingTokenAddress' | 'active'
-    | 'activeByAddressStaked' | 'activeByStaker' | 'pending' | 'pendingByStaker' | 'withdrawn' | 'withdrawnByStaker'
-  >, ForkViewerMethods {
-  /** @deprecated Use .account.balance.accountBalance instead */
-  accountBalance(address: Address, config?: ChainQualifiedConfig): Promisable<AttoXL1>
-  /** @deprecated Use .account.balance.accountBalanceHistory instead */
-  accountBalanceHistory(address: Address, config?: ChainQualifiedConfig): Promisable<AccountBalanceHistoryItem[]>
-}
-
-/** XyoViewerMethodsV2 interface. */
-export interface XyoViewerMethodsV2 {
-
-}
-
-/** Moniker identifier for the XyoViewer provider. */
-export const XyoViewerMoniker = 'XyoViewer' as const
-/** Type literal for the XyoViewer provider moniker. */
-export type XyoViewerMoniker = typeof XyoViewerMoniker
-
-/** Viewer interface for reading Xyo data. */
-export interface XyoViewer extends Omit<BlockViewer, 'moniker'>, XyoViewerMethods,
-  Omit<
-    StakeViewerMethods, 'moniker' | 'minWithdrawalBlocks' | 'rewardsContract' | 'stakingTokenAddress' | 'active'
-    | 'activeByAddressStaked' | 'activeByStaker' | 'pending' | 'pendingByStaker' | 'withdrawn' | 'withdrawnByStaker'
-  >, Provider<XyoViewerMoniker> {
-  account: {
-    balance: AccountBalanceViewer
-  }
-  block: BlockViewer
-  finalization: FinalizationViewer
-  mempool: MempoolViewer
-  networkStake: NetworkStakeViewer
-  stake: StakeViewer
-  step: StepViewer
-  time: TimeSyncViewer
-  transaction: TransactionViewer
-}
-
-/** XyoViewerV2 interface. */
-export interface XyoViewerV2 extends XyoViewerMethodsV2, Provider<XyoViewerMoniker> {
-  account: {
-    balance: AccountBalanceViewer
-  }
-  block: BlockViewer
-  finalization: FinalizationViewer
-  mempool: MempoolViewer
-  networkStake: NetworkStakeViewer
-  stake: StakeViewer
-  step: StepViewer
-  time: TimeSyncViewer
-  transaction: TransactionViewer
-}

package/src/viewers/index.ts

@@ -1,23 +0,0 @@
-export * from './Block.ts'
-export * from './BlockInvalidation.ts'
-export * from './BlockReward.ts'
-export * from './BlockValidation.ts'
-export * from './ChainContract.ts'
-export * from './ChainStakeViewer.ts'
-export * from './Finalization.ts'
-export * from './Fork.ts'
-export * from './Mempool.ts'
-export * from './NetworkStake/index.ts'
-export * from './NetworkStakeStepReward.ts'
-export * from './Stake.ts'
-export * from './StakeEvents.ts'
-export * from './StakeTotals.ts'
-export * from './StepStake.ts'
-export * from './StepViewer.ts'
-export * from './TimeSync.ts'
-export * from './Transaction.ts'
-export * from './TransactionInvalidation.ts'
-export * from './TransactionValidation.ts'
-export * from './TransferBalance.ts'
-export * from './WindowedBlock.ts'
-export * from './XyoViewer.ts'

package/src/xl1/AttoXL1.ts

@@ -1,19 +0,0 @@
-import {
-  asXL1Factory, isXL1Factory, toXL1Factory,
-} from './isXL1Factory.ts'
-import { xl1MaxValue } from './xl1MaxValue.ts'
-import { XL1Places } from './XL1Units.ts'
-
-/** Maximum value for the AttoXL1 branded type. */
-export const AttoXL1MaxValue = xl1MaxValue(XL1Places.atto)
-/** AttoXL1 type. */
-export type AttoXL1 = bigint & { readonly _tag: 'AttoXL1' }
-/** Type guard that checks if a value is a valid AttoXL1. */
-export const isAttoXL1 = isXL1Factory<AttoXL1>(XL1Places.atto)
-/** Converts a value to AttoXL1, throwing if invalid. */
-export const asAttoXL1 = asXL1Factory<AttoXL1>(XL1Places.atto)
-/** Converts a bigint value to AttoXL1 without validation. */
-export const toAttoXL1 = toXL1Factory<AttoXL1>(XL1Places.atto)
-
-/** Shorthand alias for asAttoXL1. */
-export const AttoXL1 = asAttoXL1

package/src/xl1/FemtoXL1.ts

@@ -1,20 +0,0 @@
-import {
-  asXL1Factory, isXL1Factory, toXL1Factory,
-} from './isXL1Factory.ts'
-import { xl1MaxValue } from './xl1MaxValue.ts'
-import { XL1Places } from './XL1Units.ts'
-
-/** Maximum value for the FemtoXL1 branded type. */
-export const FemtoXL1MaxValue = xl1MaxValue(XL1Places.femto)
-/** FemtoXL1 type. */
-export type FemtoXL1 = bigint & { readonly _tag: 'FemtoXL1' }
-/** Type guard that checks if a value is a valid FemtoXL1. */
-export const isFemtoXL1 = isXL1Factory<FemtoXL1>(XL1Places.femto)
-/** Converts a value to FemtoXL1, throwing if invalid. */
-export const asFemtoXL1 = asXL1Factory<FemtoXL1>(XL1Places.femto)
-
-/** Converts a bigint value to FemtoXL1 without validation. */
-export const toFemtoXL1 = toXL1Factory<FemtoXL1>(XL1Places.femto)
-
-/** Shorthand alias for asFemtoXL1. */
-export const FemtoXL1 = asFemtoXL1

package/src/xl1/MicroXL1.ts

@@ -1,20 +0,0 @@
-import {
-  asXL1Factory, isXL1Factory, toXL1Factory,
-} from './isXL1Factory.ts'
-import { xl1MaxValue } from './xl1MaxValue.ts'
-import { XL1Places } from './XL1Units.ts'
-
-/** Maximum value for the MicroXL1 branded type. */
-export const MicroXL1MaxValue = xl1MaxValue(XL1Places.micro)
-/** MicroXL1 type. */
-export type MicroXL1 = bigint & { readonly _tag: 'MicroXL1' }
-/** Type guard that checks if a value is a valid MicroXL1. */
-export const isMicroXL1 = isXL1Factory<MicroXL1>(XL1Places.micro)
-/** Converts a value to MicroXL1, throwing if invalid. */
-export const asMicroXL1 = asXL1Factory<MicroXL1>(XL1Places.micro)
-
-/** Converts a bigint value to MicroXL1 without validation. */
-export const toMicroXL1 = toXL1Factory<MicroXL1>(XL1Places.micro)
-
-/** Shorthand alias for asMicroXL1. */
-export const MicroXL1 = asMicroXL1

package/src/xl1/MilliXL1.ts

@@ -1,20 +0,0 @@
-import {
-  asXL1Factory, isXL1Factory, toXL1Factory,
-} from './isXL1Factory.ts'
-import { xl1MaxValue } from './xl1MaxValue.ts'
-import { XL1Places } from './XL1Units.ts'
-
-/** Maximum value for the MilliXL1 branded type. */
-export const MilliXL1MaxValue = xl1MaxValue(XL1Places.milli)
-/** MilliXL1 type. */
-export type MilliXL1 = bigint & { readonly _tag: 'MilliXL1' }
-/** Type guard that checks if a value is a valid MilliXL1. */
-export const isMilliXL1 = isXL1Factory<MilliXL1>(XL1Places.milli)
-/** Converts a value to MilliXL1, throwing if invalid. */
-export const asMilliXL1 = asXL1Factory<MilliXL1>(XL1Places.milli)
-
-/** Converts a bigint value to MilliXL1 without validation. */
-export const toMilliXL1 = toXL1Factory<MilliXL1>(XL1Places.milli)
-
-/** Shorthand alias for asMilliXL1. */
-export const MilliXL1 = asMilliXL1

package/src/xl1/NanoXL1.ts

@@ -1,20 +0,0 @@
-import {
-  asXL1Factory, isXL1Factory, toXL1Factory,
-} from './isXL1Factory.ts'
-import { xl1MaxValue } from './xl1MaxValue.ts'
-import { XL1Places } from './XL1Units.ts'
-
-/** Maximum value for the NanoXL1 branded type. */
-export const NanoXL1MaxValue = xl1MaxValue(XL1Places.nano)
-/** NanoXL1 type. */
-export type NanoXL1 = bigint & { readonly _tag: 'NanoXL1' }
-/** Type guard that checks if a value is a valid NanoXL1. */
-export const isNanoXL1 = isXL1Factory<NanoXL1>(XL1Places.nano)
-/** Converts a value to NanoXL1, throwing if invalid. */
-export const asNanoXL1 = asXL1Factory<NanoXL1>(XL1Places.nano)
-
-/** Converts a bigint value to NanoXL1 without validation. */
-export const toNanoXL1 = toXL1Factory<NanoXL1>(XL1Places.nano)
-
-/** Shorthand alias for asNanoXL1. */
-export const NanoXL1 = asNanoXL1

package/src/xl1/PicoXL1.ts

@@ -1,20 +0,0 @@
-import {
-  asXL1Factory, isXL1Factory, toXL1Factory,
-} from './isXL1Factory.ts'
-import { xl1MaxValue } from './xl1MaxValue.ts'
-import { XL1Places } from './XL1Units.ts'
-
-/** PicoXL1MaxValue constant. */
-export const PicoXL1MaxValue = xl1MaxValue(XL1Places.pico)
-/** PicoXL1 type. */
-export type PicoXL1 = bigint & { readonly _tag: 'PicoXL1' }
-/** Type guard that checks if a value is a valid PicoXL1. */
-export const isPicoXL1 = isXL1Factory<PicoXL1>(XL1Places.pico)
-/** Converts a value to PicoXL1, throwing if invalid. */
-export const asPicoXL1 = asXL1Factory<PicoXL1>(XL1Places.pico)
-
-/** toPicoXL1 constant. */
-export const toPicoXL1 = toXL1Factory<PicoXL1>(XL1Places.pico)
-
-/** PicoXL1 constant. */
-export const PicoXL1 = asPicoXL1

package/src/xl1/XL1.ts

@@ -1,20 +0,0 @@
-import {
-  asXL1Factory, isXL1Factory, toXL1Factory,
-} from './isXL1Factory.ts'
-import { xl1MaxValue } from './xl1MaxValue.ts'
-import { XL1Places } from './XL1Units.ts'
-
-/** XL1MaxValue constant. */
-export const XL1MaxValue = xl1MaxValue(XL1Places.xl1)
-/** XL1 type. */
-export type XL1 = bigint & { readonly _tag: 'XL1' }
-/** Type guard that checks if a value is a valid XL1. */
-export const isXL1 = isXL1Factory<XL1>(XL1Places.xl1)
-/** Converts a value to XL1, throwing if invalid. */
-export const asXL1 = asXL1Factory<XL1>(XL1Places.xl1)
-
-/** toXL1 constant. */
-export const toXL1 = toXL1Factory<XL1>(XL1Places.xl1)
-
-/** XL1 constant. */
-export const XL1 = asXL1

package/src/xl1/XL1Units.ts

@@ -1,26 +0,0 @@
-type XL1Units = 'xl1' | 'milli' | 'micro' | 'nano' | 'pico' | 'femto' | 'atto'
-
-/** Decimal place definitions for each XL1 currency unit (atto=18, femto=15, etc.). */
-export const XL1Places: Record<XL1Units, bigint> = {
-  xl1: 18n,
-  milli: 15n,
-  micro: 12n,
-  nano: 9n,
-  pico: 6n,
-  femto: 3n,
-  atto: 0n,
-} as const
-
-/**
- * Convert factor by which a respective unit is multiplied to convert it to AttoXL1 or
- * by which AttoXL1 is divided to convert it to respective unit is multiplied.
- */
-export const AttoXL1ConvertFactor: Record<XL1Units, bigint> = {
-  xl1: 10n ** XL1Places.xl1,
-  milli: 10n ** XL1Places.milli,
-  micro: 10n ** XL1Places.micro,
-  nano: 10n ** XL1Places.nano,
-  pico: 10n ** XL1Places.pico,
-  femto: 10n ** XL1Places.femto,
-  atto: 10n ** XL1Places.atto,
-} as const

package/src/xl1/index.ts

@@ -1,8 +0,0 @@
-export * from './AttoXL1.ts'
-export * from './FemtoXL1.ts'
-export * from './MicroXL1.ts'
-export * from './MilliXL1.ts'
-export * from './NanoXL1.ts'
-export * from './PicoXL1.ts'
-export * from './XL1.ts'
-export * from './XL1Units.ts'

package/src/xl1/isXL1Factory.ts

@@ -1,56 +0,0 @@
-import { z } from 'zod'
-
-import { xl1MaxValue } from './xl1MaxValue.ts'
-
-/** Type guard that checks if a value is a valid XL1Factory. */
-export const isXL1Factory = <T extends bigint>(places: bigint) => (val: unknown): val is T => {
-  if (typeof val !== 'bigint') return false
-  return val >= 0n && val <= xl1MaxValue(places)
-}
-
-/** Creates a Zod schema factory for XL1 branded bigint types. */
-export const XL1ZodFactory = <T extends bigint>(places: bigint, name: string) => {
-  const is = isXL1Factory<T>(places)
-  const message = `Invalid value for ${name}, must be between 0 and ${xl1MaxValue(places)}`
-  return z.bigint().refine(
-    (x) => {
-      const result = is(x)
-      return result
-    },
-    { message },
-  )
-}
-
-/** Creates a Zod transform factory that converts values between XL1 unit types. */
-export const XL1TransformZodFactory = <T extends bigint>(places: bigint, name: string) => {
-  const is = isXL1Factory<T>(places)
-  const message = `Invalid value for ${name}, must be between 0 and ${xl1MaxValue(places)}`
-  return z.union([z.bigint(), z.number(), z.string(), z.boolean()]).transform(val => BigInt(val) as T).refine(
-    (x) => {
-      const result = is(x)
-      return result
-    },
-    { message },
-  )
-}
-
-/** Converts a value to XL1Factory, throwing if invalid. */
-export const asXL1Factory = <T extends bigint>(places: bigint) => {
-  const zod = XL1ZodFactory<T>(places, 'local')
-  return (val: unknown): T => {
-    const result = zod.safeParse(val)
-    if (result.success) {
-      return result.data as T
-    }
-    throw result.error
-  }
-}
-
-/** Creates a factory function that converts bigint values to a specific XL1 branded type. */
-export const toXL1Factory = <T extends bigint>(places: bigint) => {
-  const zod = XL1TransformZodFactory<T>(places, 'local')
-  return (val: unknown): T | undefined => {
-    const result = zod.safeParse(val)
-    return result.success ? result.data as T : undefined
-  }
-}

package/src/xl1/xl1MaxValue.ts

@@ -1,2 +0,0 @@
-/** Computes the maximum value for an XL1 unit given its decimal places. */
-export const xl1MaxValue = (places: bigint) => 10n ** (32n - places) - 1n