@xyo-network/xl1-protocol 1.25.26 → 1.25.28

package/src/block/HydratedBlock.ts

@@ -10,88 +10,125 @@ import { z } from 'zod'
 import { BlockBoundWitnessZod } from './BlockBoundWitness.ts'
 import { SignedBlockBoundWitnessZod } from './signed/index.ts'
 
+/** HydratedBlockZod constant. */
 export const HydratedBlockZod = z.tuple([
   BlockBoundWitnessZod,
   z.array(PayloadZodLoose),
 ])
 
+/** Type representing a hydrated Block with resolved payloads. */
 export type HydratedBlock = z.infer<typeof HydratedBlockZod>
 
+/** Type guard that checks if a value is a valid HydratedBlock. */
 export const isHydratedBlock = zodIsFactory(HydratedBlockZod)
+/** Converts a value to HydratedBlock, throwing if invalid. */
 export const asHydratedBlock = zodAsFactory(HydratedBlockZod, 'asHydratedBlock')
+/** toHydratedBlock constant. */
 export const toHydratedBlock = zodToFactory(HydratedBlockZod, 'toHydratedBlock')
 
+/** HydratedBlockWithHashMetaZod constant. */
 export const HydratedBlockWithHashMetaZod = z.tuple([
   WithHashMetaZod(BlockBoundWitnessZod),
   z.array(WithHashMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated BlockWithHashMeta with resolved payloads. */
 export type HydratedBlockWithHashMeta = z.infer<typeof HydratedBlockWithHashMetaZod>
 
+/** Type guard that checks if a value is a valid HydratedBlockWithHashMeta. */
 export const isHydratedBlockWithHashMeta = zodIsFactory(HydratedBlockWithHashMetaZod)
+/** Converts a value to HydratedBlockWithHashMeta, throwing if invalid. */
 export const asHydratedBlockWithHashMeta = zodAsFactory(HydratedBlockWithHashMetaZod, 'asHydratedBlockWithHashMeta')
+/** toHydratedBlockWithHashMeta constant. */
 export const toHydratedBlockWithHashMeta = zodToFactory(HydratedBlockWithHashMetaZod, 'toHydratedBlockWithHashMeta')
 
+/** HydratedBlockWithStorageMetaZod constant. */
 export const HydratedBlockWithStorageMetaZod = z.tuple([
   WithStorageMetaZod(BlockBoundWitnessZod),
   z.array(WithStorageMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated BlockWithStorageMeta with resolved payloads. */
 export type HydratedBlockWithStorageMeta = z.infer<typeof HydratedBlockWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid HydratedBlockWithStorageMeta. */
 export const isHydratedBlockWithStorageMeta = zodIsFactory(HydratedBlockWithStorageMetaZod)
+/** Converts a value to HydratedBlockWithStorageMeta, throwing if invalid. */
 export const asHydratedBlockWithStorageMeta = zodAsFactory(HydratedBlockWithStorageMetaZod, 'asHydratedBlockWithStorageMeta')
+/** toHydratedBlockWithStorageMeta constant. */
 export const toHydratedBlockWithStorageMeta = zodToFactory(HydratedBlockWithStorageMetaZod, 'toHydratedBlockWithStorageMeta')
 
+/** SignedHydratedBlockZod constant. */
 export const SignedHydratedBlockZod = z.tuple([
   SignedBlockBoundWitnessZod,
   z.array(PayloadZod.loose()),
 ])
 
+/** Type representing a hydrated SignedBlock with resolved payloads. */
 export type SignedHydratedBlock = z.infer<typeof SignedHydratedBlockZod>
 
+/** Type guard that checks if a value is a valid SignedHydratedBlock. */
 export const isSignedHydratedBlock = zodIsFactory(SignedHydratedBlockZod)
+/** Converts a value to SignedHydratedBlock, throwing if invalid. */
 export const asSignedHydratedBlock = zodAsFactory(SignedHydratedBlockZod, 'asSignedHydratedBlock')
+/** toSignedHydratedBlock constant. */
 export const toSignedHydratedBlock = zodToFactory(SignedHydratedBlockZod, 'toSignedHydratedBlock')
 
+/** SignedHydratedBlockToJsonZod constant. */
 export const SignedHydratedBlockToJsonZod = z.tuple([
   SignedBlockBoundWitnessZod,
   z.array(PayloadZod.loose()),
 ])
 
+/** Type representing a hydrated SignedBlockToJson with resolved payloads. */
 export type SignedHydratedBlockToJson = z.infer<typeof SignedHydratedBlockToJsonZod>
 
+/** Type guard that checks if a value is a valid SignedHydratedBlockToJson. */
 export const isSignedHydratedBlockToJson = zodIsFactory(SignedHydratedBlockToJsonZod)
+/** Converts a value to SignedHydratedBlockToJson, throwing if invalid. */
 export const asSignedHydratedBlockToJson = zodAsFactory(SignedHydratedBlockToJsonZod, 'asSignedHydratedBlockToJson')
+/** toSignedHydratedBlockToJson constant. */
 export const toSignedHydratedBlockToJson = zodToFactory(SignedHydratedBlockToJsonZod, 'toSignedHydratedBlockToJson')
 
+/** SignedHydratedBlockWithHashMetaZod constant. */
 export const SignedHydratedBlockWithHashMetaZod = z.tuple([
   WithHashMetaZod(SignedBlockBoundWitnessZod),
   z.array(WithHashMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated SignedBlockWithHashMeta with resolved payloads. */
 export type SignedHydratedBlockWithHashMeta = z.infer<typeof SignedHydratedBlockWithHashMetaZod>
 
+/** SignedHydratedBlockWithHashMetaishZod constant. */
 export const SignedHydratedBlockWithHashMetaishZod = z.tuple([
   z.union([WithHashMetaZod(SignedBlockBoundWitnessZod)]),
   z.array(WithHashMetaZod(PayloadZod).loose()),
 ])
 
+/** Type guard that checks if a value is a valid SignedHydratedBlockWithHashMeta. */
 export const isSignedHydratedBlockWithHashMeta = zodIsFactory(SignedHydratedBlockWithHashMetaZod)
+/** Converts a value to SignedHydratedBlockWithHashMeta, throwing if invalid. */
 export const asSignedHydratedBlockWithHashMeta = zodAsFactory(SignedHydratedBlockWithHashMetaZod, 'asSignedHydratedBlockWithHashMeta')
 
+/** toSignedHydratedBlockWithHashMeta constant. */
 export const toSignedHydratedBlockWithHashMeta = zodToFactory(SignedHydratedBlockWithHashMetaZod, 'toSignedHydratedBlockWithHashMeta')
 
+/** SignedHydratedBlockWithStorageMetaZod constant. */
 export const SignedHydratedBlockWithStorageMetaZod = z.tuple([
   WithStorageMetaZod(SignedBlockBoundWitnessZod),
   z.array(WithStorageMetaZod(PayloadZod).loose()),
 ])
+/** Type representing a hydrated SignedBlockWithStorageMeta with resolved payloads. */
 export type SignedHydratedBlockWithStorageMeta = z.infer<typeof SignedHydratedBlockWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid SignedHydratedBlockWithStorageMeta. */
 export const isSignedHydratedBlockWithStorageMeta = zodIsFactory(SignedHydratedBlockWithStorageMetaZod)
+/** Converts a value to SignedHydratedBlockWithStorageMeta, throwing if invalid. */
 export const asSignedHydratedBlockWithStorageMeta = zodAsFactory(SignedHydratedBlockWithStorageMetaZod, 'asSignedHydratedBlockWithStorageMeta')
+/** toSignedHydratedBlockWithStorageMeta constant. */
 export const toSignedHydratedBlockWithStorageMeta = zodToFactory(SignedHydratedBlockWithStorageMetaZod, 'toSignedHydratedBlockWithStorageMeta')
 
+/** SignedHydratedBlockWithStorageMetaishZod constant. */
 export const SignedHydratedBlockWithStorageMetaishZod = z.tuple([
   z.union([WithStorageMetaZod(SignedBlockBoundWitnessZod)]),
   z.array(WithStorageMetaZod(PayloadZod).loose()),

package/src/block/signed/SignedBlockBoundWitness.ts

@@ -6,12 +6,17 @@ import type { z } from 'zod'
 
 import { BlockBoundWitnessFieldsZod, BlockBoundWitnessMetaZod } from '../BlockBoundWitness.ts'
 
+/** SignedBlockBoundWitnessZod constant. */
 export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
   .safeExtend(BlockBoundWitnessFieldsZod.shape)
   .safeExtend(BlockBoundWitnessMetaZod.shape)
 
+/** SignedBlockBoundWitness type. */
 export type SignedBlockBoundWitness = z.infer<typeof SignedBlockBoundWitnessZod>
 
+/** Type guard that checks if a value is a valid SignedBlockBoundWitness. */
 export const isSignedBlockBoundWitness = zodIsFactory(SignedBlockBoundWitnessZod)
+/** Converts a value to SignedBlockBoundWitness, throwing if invalid. */
 export const asSignedBlockBoundWitness = zodAsFactory(SignedBlockBoundWitnessZod, 'asSignedBlockBoundWitness')
+/** toSignedBlockBoundWitness constant. */
 export const toSignedBlockBoundWitness = zodToFactory(SignedBlockBoundWitnessZod, 'toSignedBlockBoundWitness')

package/src/block/signed/SignedBlockBoundWitnessWithHashMeta.ts

@@ -6,13 +6,18 @@ import type { z } from 'zod'
 
 import { isSignedBlockBoundWitness, SignedBlockBoundWitnessZod } from './SignedBlockBoundWitness.ts'
 
+/** SignedBlockBoundWitnessWithHashMetaZod constant. */
 export const SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedBlockBoundWitnessZod)
 
+/** SignedBlockBoundWitnessWithHashMeta type. */
 export type SignedBlockBoundWitnessWithHashMeta = z.infer<typeof SignedBlockBoundWitnessWithHashMetaZod>
 
+/** Type guard that checks if a value is a valid SignedBlockBoundWitnessWithHashMeta. */
 export const isSignedBlockBoundWitnessWithHashMeta = zodIsFactory(SignedBlockBoundWitnessWithHashMetaZod)
+/** Converts a value to SignedBlockBoundWitnessWithHashMeta, throwing if invalid. */
 export const asSignedBlockBoundWitnessWithHashMeta = zodAsFactory(SignedBlockBoundWitnessWithHashMetaZod, 'asSignedBlockBoundWitnessWithHashMeta')
 
+/** SignedBlockBoundWitnessWithHashMetaishZod constant. */
 export const SignedBlockBoundWitnessWithHashMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
   if (isSignedBlockBoundWitnessWithHashMeta(data)) {
     return data
@@ -23,6 +28,8 @@ export const SignedBlockBoundWitnessWithHashMetaishZod = SignedBlockBoundWitness
   throw new Error('Invalid SignedBlockBoundWitnessWithHashMetaish format')
 })
 
+/** SignedBlockBoundWitnessWithHashMetaish type. */
 export type SignedBlockBoundWitnessWithHashMetaish = z.input<typeof SignedBlockBoundWitnessWithHashMetaishZod>
 
+/** toSignedBlockBoundWitnessWithHashMeta constant. */
 export const toSignedBlockBoundWitnessWithHashMeta = zodToFactory(SignedBlockBoundWitnessWithHashMetaZod, 'toSignedBlockBoundWitnessWithHashMeta')

package/src/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts

@@ -6,16 +6,21 @@ import type { z } from 'zod'
 
 import { isSignedBlockBoundWitness, SignedBlockBoundWitnessZod } from './SignedBlockBoundWitness.ts'
 
+/** SignedBlockBoundWitnessWithStorageMetaZod constant. */
 export const SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedBlockBoundWitnessZod)
 
+/** SignedBlockBoundWitnessWithStorageMeta type. */
 export type SignedBlockBoundWitnessWithStorageMeta = z.infer<typeof SignedBlockBoundWitnessWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid SignedBlockBoundWitnessWithStorageMeta. */
 export const isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory(SignedBlockBoundWitnessWithStorageMetaZod)
+/** Converts a value to SignedBlockBoundWitnessWithStorageMeta, throwing if invalid. */
 export const asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory(
   SignedBlockBoundWitnessWithStorageMetaZod,
   'asSignedBlockBoundWitnessWithStorageMeta',
 )
 
+/** SignedBlockBoundWitnessWithStorageMetaishZod constant. */
 export const SignedBlockBoundWitnessWithStorageMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
   if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
     return data
@@ -26,8 +31,10 @@ export const SignedBlockBoundWitnessWithStorageMetaishZod = SignedBlockBoundWitn
   throw new Error('Invalid SignedBlockBoundWitnessWithStorageMetaish format')
 })
 
+/** SignedBlockBoundWitnessWithStorageMetaish type. */
 export type SignedBlockBoundWitnessWithStorageMetaish = z.input<typeof SignedBlockBoundWitnessWithStorageMetaishZod>
 
+/** toSignedBlockBoundWitnessWithStorageMeta constant. */
 export const toSignedBlockBoundWitnessWithStorageMeta = zodToFactory(
   SignedBlockBoundWitnessWithStorageMetaishZod,
   'toSignedBlockBoundWitnessWithStorageMeta',

package/src/block/unsigned/UnsignedBlockBoundWitness.ts

@@ -6,12 +6,17 @@ import type { z } from 'zod'
 
 import { BlockBoundWitnessFieldsZod, BlockBoundWitnessMetaZod } from '../BlockBoundWitness.ts'
 
+/** UnsignedBlockBoundWitnessZod constant. */
 export const UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod
   .safeExtend(BlockBoundWitnessFieldsZod.shape)
   .safeExtend(BlockBoundWitnessMetaZod.shape)
 
+/** UnsignedBlockBoundWitness type. */
 export type UnsignedBlockBoundWitness = z.infer<typeof UnsignedBlockBoundWitnessZod>
 
+/** Type guard that checks if a value is a valid UnsignedBlockBoundWitness. */
 export const isUnsignedBlockBoundWitness = zodIsFactory(UnsignedBlockBoundWitnessZod)
+/** Converts a value to UnsignedBlockBoundWitness, throwing if invalid. */
 export const asUnsignedBlockBoundWitness = zodAsFactory(UnsignedBlockBoundWitnessZod, 'asUnsignedBlockBoundWitness')
+/** toUnsignedBlockBoundWitness constant. */
 export const toUnsignedBlockBoundWitness = zodToFactory(UnsignedBlockBoundWitnessZod, 'toUnsignedBlockBoundWitness')

package/src/chain/Chain.ts

@@ -3,4 +3,5 @@ import { z } from 'zod'
 
 import type { ChainId } from './ChainId.ts'
 
+/** ChainZod constant. */
 export const ChainZod = z.string().toLowerCase().regex(AddressRegEx).transform<ChainId>(v => toAddress(v) as ChainId)

package/src/chain/ChainAnalyzer.ts

@@ -3,6 +3,7 @@ import type { Payload } from '@xyo-network/sdk-js'
 
 import type { HydratedBlock } from '../block/index.ts'
 
+/** ChainAnalyzer interface. */
 export interface ChainAnalyzer<T extends Payload = Payload> {
   onBlock(block: HydratedBlock): Promisable<boolean>
   result(): T

package/src/chain/ChainId.ts

@@ -1,3 +1,4 @@
 import type { Hex } from '@xylabs/sdk-js'
 
+/** ChainId type. */
 export type ChainId = Hex

package/src/fields/Addressable.ts

@@ -1,6 +1,7 @@
 import type { Address } from '@xylabs/sdk-js'
 
 // NOTE: Minimal interface in case of reuse across validators, producers, wallets, modules, etc.
+/** Addressable interface. */
 export interface Addressable {
   address: Address
 }

package/src/fields/BlockDuration.ts

@@ -1,3 +1,4 @@
+/** BlockStart interface. */
 export interface BlockStart {
   /**
    * The block at which the duration starts
@@ -5,6 +6,7 @@ export interface BlockStart {
   nbf: number
 }
 
+/** BlockEnd interface. */
 export interface BlockEnd {
   /**
    * The block at which the duration ends

package/src/fields/BlockNumber.ts

@@ -8,9 +8,12 @@ import {
 
 import type { XL1BlockNumber } from '../BlockNumber/index.ts'
 
+/** Schema identifier for BlockNumber payloads. */
 export const BlockNumberSchema = asSchema('network.xyo.chain.block.number', true)
+/** Schema type for BlockNumber payloads. */
 export type BlockNumberSchema = typeof BlockNumberSchema
 
+/** BlockNumberFields interface. */
 export interface BlockNumberFields {
   /**
    * The block number
@@ -26,10 +29,12 @@ export type BlockNumberPayload = Payload<BlockNumberFields, BlockNumberSchema>
  * Identity function for determining if an object is a BlockNumber
  */
 export const isBlockNumberPayload = isPayloadOfSchemaType<BlockNumberPayload>(BlockNumberSchema)
+/** Converts a value to BlockNumberPayload, throwing if invalid. */
 export const asBlockNumberPayload = AsObjectFactory.create<BlockNumberPayload>(isBlockNumberPayload)
 
 /**
  * Identity function for determining if an object is a BlockNumber with sources
  */
 export const isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources<BlockNumberPayload>(BlockNumberSchema)
+/** Converts a value to BlockNumberPayloadWithSources, throwing if invalid. */
 export const asBlockNumberPayloadWithSources = AsObjectFactory.create<WithSources<BlockNumberPayload>>(isBlockNumberPayloadWithSources)

package/src/map/AsyncMap.ts

@@ -1,5 +1,6 @@
 import type { Promisable } from '@xylabs/sdk-js'
 
+/** AsyncMapRead interface. */
 export interface AsyncMapRead<K, V> {
   get(id: K): Promisable<V | undefined>
   getMany(id: K[]): Promisable<V[]>
@@ -10,6 +11,7 @@ export interface AsyncMapRead<K, V> {
  */
 export interface AsynchronousMapRead<K, V> extends AsyncMapRead<K, V> {}
 
+/** AsyncMapWrite interface. */
 export interface AsyncMapWrite<K, V> {
   clear(): Promisable<void>
   delete(id: K): Promisable<boolean>
@@ -21,12 +23,16 @@ export interface AsyncMapWrite<K, V> {
  */
 export interface AsynchronousMapWrite<K, V> extends AsyncMapWrite<K, V> {}
 
+/** AsyncMap interface. */
 export interface AsyncMap<K, V> extends AsyncMapRead<K, V>, AsyncMapWrite<K, V> {}
 /**
  * @deprecated Use AsyncMap instead
  */
 export interface AsynchronousMap<K, V> extends AsyncMap<K, V> {}
 
+/** AsyncIterableMapRead interface. */
 export interface AsyncIterableMapRead<K, V>extends AsyncMapRead<K, V>, AsyncIterable<[K, V]> {}
+/** AsyncIterableMapWrite interface. */
 export interface AsyncIterableMapWrite<K, V>extends AsyncMapWrite<K, V>, AsyncIterable<[K, V]> {}
+/** AsyncIterableMap interface. */
 export interface AsyncIterableMap<K, V>extends AsyncMap<K, V>, AsyncIterable<[K, V]> {}

package/src/map/MapType.ts

@@ -5,16 +5,23 @@ import type {
   SyncIterableMap, SyncIterableMapRead, SyncIterableMapWrite, SyncMap, SyncMapRead, SyncMapWrite,
 } from './SyncMap.ts'
 
+/** MapType type. */
 export type MapType<TId, TData> = SyncMap<TId, TData> | AsyncMap<TId, TData>
 
+/** MapTypeRead type. */
 export type MapTypeRead<TId, TData> = SyncMapRead<TId, TData> | AsyncMapRead<TId, TData>
 
+/** MapTypeWrite type. */
 export type MapTypeWrite<TId, TData> = SyncMapWrite<TId, TData> | AsyncMapWrite<TId, TData>
 
+/** AsynchronousMapType type. */
 export type AsynchronousMapType<TId, TData> = AsyncMapRead<TId, TData> & AsyncMapWrite<TId, TData>
 
+/** IterableMapRead type. */
 export type IterableMapRead<TId, TData> = SyncIterableMapRead<TId, TData> | AsyncIterableMapRead<TId, TData>
 
+/** IterableMapWrite type. */
 export type IterableMapWrite<TId, TData> = SyncIterableMapWrite<TId, TData> | AsyncIterableMapWrite<TId, TData>
 
+/** IterableMap type. */
 export type IterableMap<TId, TData> = SyncIterableMap<TId, TData> | AsyncIterableMap<TId, TData>

package/src/map/SyncMap.ts

@@ -1,3 +1,4 @@
+/** SyncMapRead interface. */
 export interface SyncMapRead<K, V> {
   get(id: K): V | undefined
   getMany(id: K[]): V[]
@@ -9,6 +10,7 @@ export interface SyncMapRead<K, V> {
  */
 export interface SynchronousMapRead<K, V> extends SyncMapRead<K, V> {}
 
+/** SyncMapWrite interface. */
 export interface SyncMapWrite<K, V> {
   clear(): void
   delete(id: K): boolean
@@ -21,12 +23,16 @@ export interface SyncMapWrite<K, V> {
  */
 export interface SynchronousMapWrite<K, V> extends SyncMapWrite<K, V> {}
 
+/** SyncMap interface. */
 export interface SyncMap<K, V> extends SyncMapRead<K, V>, SyncMapWrite<K, V> {}
 /**
  * @deprecated Use SyncMap instead
  */
 export interface SynchronousMap<K, V> extends SyncMap<K, V> {}
 
+/** SyncIterableMapRead interface. */
 export interface SyncIterableMapRead<K, V> extends SyncMapRead<K, V>, Iterable<[K, V]> {}
+/** SyncIterableMapWrite interface. */
 export interface SyncIterableMapWrite<K, V> extends SyncMapWrite<K, V>, Iterable<[K, V]> {}
+/** SyncIterableMap interface. */
 export interface SyncIterableMap<K, V> extends SyncMap<K, V>, Iterable<[K, V]> {}

package/src/model/AccountBalance.ts

@@ -11,22 +11,31 @@ import type { AttoXL1 } from '../xl1/index.ts'
 import type { ChainQualified } from './ChainQualification.ts'
 import { ChainQualificationZod, ChainQualifiedConfigZod } from './ChainQualification.ts'
 
+/** AccountBalanceHistoryItemZod constant. */
 export const AccountBalanceHistoryItemZod = z.tuple([
   WithHashMetaZod(BlockBoundWitnessZod),
   WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
   WithHashMetaZod(TransferZod),
 ])
 
+/** AccountBalanceHistoryItem type. */
 export type AccountBalanceHistoryItem = z.infer<typeof AccountBalanceHistoryItemZod>
 
+/** AccountBalanceQualificationZod constant. */
 export const AccountBalanceQualificationZod = ChainQualificationZod
+/** AccountBalanceQualification type. */
 export type AccountBalanceQualification = z.infer<typeof AccountBalanceQualificationZod>
+/** Type guard that checks if a value is a valid AccountBalanceQualification. */
 export const isAccountBalanceQualification = zodIsFactory(AccountBalanceQualificationZod)
 
+/** AccountBalanceConfigZod constant. */
 export const AccountBalanceConfigZod = ChainQualifiedConfigZod
+/** AccountBalanceConfig type. */
 export type AccountBalanceConfig = z.infer<typeof AccountBalanceConfigZod>
+/** Type guard that checks if a value is a valid AccountBalanceConfig. */
 export const isAccountBalanceConfig = zodIsFactory(AccountBalanceConfigZod)
 
+/** AccountBalanceViewerMethods interface. */
 export interface AccountBalanceViewerMethods {
   qualifiedAccountBalanceHistories(
     address: Address[],
@@ -35,6 +44,7 @@ export interface AccountBalanceViewerMethods {
   qualifiedAccountBalances(address: Address[], config: AccountBalanceConfig): Promisable<ChainQualified<Record<Address, AttoXL1>>>
 }
 
+/** Viewer interface for reading AccountBalance data. */
 export interface AccountBalanceViewer extends AccountBalanceViewerMethods, Provider<AccountBalanceViewerMoniker> {
   accountBalance(address: Address, config?: AccountBalanceConfig): Promisable<AttoXL1>
   accountBalanceHistories(address: Address[], config?: AccountBalanceConfig): Promisable<Record<Address, AccountBalanceHistoryItem[]>>
@@ -42,5 +52,7 @@ export interface AccountBalanceViewer extends AccountBalanceViewerMethods, Provi
   accountBalances(address: Address[], config?: AccountBalanceConfig): Promisable<Record<Address, AttoXL1>>
 }
 
+/** Moniker identifier for the AccountBalanceViewer provider. */
 export const AccountBalanceViewerMoniker = 'AccountBalanceViewer' as const
+/** Type literal for the AccountBalanceViewer provider moniker. */
 export type AccountBalanceViewerMoniker = typeof AccountBalanceViewerMoniker

package/src/model/ArrayBuffer.ts

@@ -31,11 +31,13 @@ function base64Decode(b64: string): Uint8Array {
   return u8
 }
 
+/** ArrayBufferToJsonZod constant. */
 export const ArrayBufferToJsonZod = z.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x)
   return base64Encode(u8)
 })
 
+/** JsonToArrayBufferZod constant. */
 export const JsonToArrayBufferZod = z.string().transform((x) => {
   const u8 = base64Decode(x)
   return u8.buffer

package/src/model/BlockRange/BlockRange.ts

@@ -10,21 +10,32 @@ import {
   type BlockNumber, BlockNumberishZod, BlockNumberZod,
 } from '../../BlockNumber/index.ts'
 
+/** BlockRange type. */
 export type BlockRange = [BlockNumber, BlockNumber]
 
+/** BlockRangeZod constant. */
 export const BlockRangeZod = z.tuple([BlockNumberZod, BlockNumberZod])
+/** BlockRangeishZod constant. */
 export const BlockRangeishZod = z.tuple([BlockNumberishZod, BlockNumberishZod])
 
+/** BlockRangeish type. */
 export type BlockRangeish = z.input<typeof BlockRangeishZod>
 
+/** Converts a value to BlockRange, throwing if invalid. */
 export const asBlockRange = zodAsFactory<BlockRange>(BlockRangeZod, 'BlockRange')
+/** toBlockRange constant. */
 export const toBlockRange = zodToFactory<BlockRange>(BlockRangeishZod, 'BlockRange')
 
+/** BlockRangeKey type. */
 export type BlockRangeKey = Brand<string, { readonly __blockRangeKey: true }>
+/** toBlockNumberKey constant. */
 export const toBlockNumberKey = (range: BlockRange) => `${range[0]}|${range[1]}` as BlockRangeKey
 
+/** Creates a value from BlockNumberKey input. */
 export function fromBlockNumberKey(key: BlockRangeKey): BlockRange | undefined
+/** Creates a value from BlockNumberKey input. */
 export function fromBlockNumberKey(key: BlockRangeKey, assert: AssertConfig): BlockRange
+/** Creates a value from BlockNumberKey input. */
 export function fromBlockNumberKey(key: BlockRangeKey, assert?: AssertConfig): BlockRange | undefined {
   const [start, end] = key.split('|').map(v => asBlockNumber(Number(v)))
   const result = (isDefined(start) && isDefined(end)) ? [start, end] : undefined

package/src/model/BlockRange/EthBlockRange.ts

@@ -10,21 +10,32 @@ import {
   type EthBlockNumber, EthBlockNumberishZod, EthBlockNumberZod,
 } from '../../BlockNumber/index.ts'
 
+/** EthBlockRange type. */
 export type EthBlockRange = [EthBlockNumber, EthBlockNumber]
 
+/** EthBlockRangeZod constant. */
 export const EthBlockRangeZod = z.tuple([EthBlockNumberZod, EthBlockNumberZod])
+/** EthBlockRangeishZod constant. */
 export const EthBlockRangeishZod = z.tuple([EthBlockNumberishZod, EthBlockNumberishZod])
 
+/** EthBlockRangeish type. */
 export type EthBlockRangeish = z.input<typeof EthBlockRangeishZod>
 
+/** Converts a value to EthBlockRange, throwing if invalid. */
 export const asEthBlockRange = zodAsFactory<EthBlockRange>(EthBlockRangeZod, 'EthBlockRange')
+/** toEthBlockRange constant. */
 export const toEthBlockRange = zodToFactory<EthBlockRange>(EthBlockRangeishZod, 'EthBlockRange')
 
+/** EthBlockRangeKey type. */
 export type EthBlockRangeKey = Brand<string, { readonly __ethBlockRangeKey: true }>
+/** toEthBlockNumberKey constant. */
 export const toEthBlockNumberKey = (range: EthBlockRange) => `${range[0]}|${range[1]}` as EthBlockRangeKey
 
+/** Creates a value from EthBlockNumberKey input. */
 export function fromEthBlockNumberKey(key: EthBlockRangeKey): EthBlockRange | undefined
+/** Creates a value from EthBlockNumberKey input. */
 export function fromEthBlockNumberKey(key: EthBlockRangeKey, assert: AssertConfig): EthBlockRange
+/** Creates a value from EthBlockNumberKey input. */
 export function fromEthBlockNumberKey(key: EthBlockRangeKey, assert?: AssertConfig): EthBlockRange | undefined {
   const [start, end] = key.split('|').map(v => asEthBlockNumber(Number(v)))
   const result = (isDefined(start) && isDefined(end)) ? [start, end] : undefined

package/src/model/BlockRange/Numberish.ts

@@ -2,4 +2,5 @@ import { z } from 'zod'
 
 import { NumberishZod } from '../../BlockNumber/index.ts'
 
+/** NumberishRangeZod constant. */
 export const NumberishRangeZod = z.tuple([NumberishZod, NumberishZod])

package/src/model/BlockRange/Range.ts

@@ -3,10 +3,15 @@ import {
 } from '@xylabs/sdk-js'
 import { z } from 'zod'
 
+/** RangeZod constant. */
 export const RangeZod = z.tuple([z.number(), z.number()])
 
+/** Range type. */
 export type Range = z.infer<typeof RangeZod>
 
+/** Type guard that checks if a value is a valid Range. */
 export const isRange = zodIsFactory<Range>(RangeZod)
+/** Converts a value to Range, throwing if invalid. */
 export const asRange = zodAsFactory<Range>(RangeZod, 'Range')
+/** toRange constant. */
 export const toRange = zodToFactory<Range>(RangeZod, 'Range')

package/src/model/BlockRange/XL1BlockRange.ts

@@ -10,21 +10,32 @@ import {
   type XL1BlockNumber, XL1BlockNumberishZod, XL1BlockNumberZod,
 } from '../../BlockNumber/index.ts'
 
+/** XL1BlockRange type. */
 export type XL1BlockRange = [XL1BlockNumber, XL1BlockNumber]
 
+/** XL1BlockRangeZod constant. */
 export const XL1BlockRangeZod = z.tuple([XL1BlockNumberZod, XL1BlockNumberZod])
+/** XL1BlockRangeishZod constant. */
 export const XL1BlockRangeishZod = z.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod])
 
+/** XL1BlockRangeish type. */
 export type XL1BlockRangeish = z.input<typeof XL1BlockRangeishZod>
 
+/** Converts a value to XL1BlockRange, throwing if invalid. */
 export const asXL1BlockRange = zodAsFactory<XL1BlockRange>(XL1BlockRangeZod, 'XL1BlockRange')
+/** toXL1BlockRange constant. */
 export const toXL1BlockRange = zodToFactory<XL1BlockRange>(XL1BlockRangeishZod, 'XL1BlockRange')
 
+/** XL1BlockRangeKey type. */
 export type XL1BlockRangeKey = Brand<string, { readonly __xl1BlockRangeKey: true }>
+/** toXL1BlockNumberKey constant. */
 export const toXL1BlockNumberKey = (range: XL1BlockRange) => `${range[0]}|${range[1]}` as XL1BlockRangeKey
 
+/** Creates a value from XL1BlockNumberKey input. */
 export function fromXL1BlockNumberKey(key: XL1BlockRangeKey): XL1BlockRange | undefined
+/** Creates a value from XL1BlockNumberKey input. */
 export function fromXL1BlockNumberKey(key: XL1BlockRangeKey, assert: AssertConfig): XL1BlockRange
+/** Creates a value from XL1BlockNumberKey input. */
 export function fromXL1BlockNumberKey(key: XL1BlockRangeKey, assert?: AssertConfig): XL1BlockRange | undefined {
   const [start, end] = key.split('|').map(v => asXL1BlockNumber(Number(v)))
   const result = (isDefined(start) && isDefined(end)) ? [start, end] : undefined