@xyo-network/xl1-protocol 1.25.26 → 1.25.28

package/src/runners/Block.ts

@@ -5,14 +5,18 @@ import type {
 } from '../block/index.ts'
 import type { Provider } from '../provider/index.ts'
 
+/** BlockRunnerMethods interface. */
 export interface BlockRunnerMethods {
   produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force: true): Promise<SignedHydratedBlockWithHashMeta>
   produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force?: false): Promise<SignedHydratedBlockWithHashMeta | undefined>
 }
 
+/** Moniker identifier for the BlockRunner provider. */
 export const BlockRunnerMoniker = 'BlockRunner' as const
+/** Type literal for the BlockRunner provider moniker. */
 export type BlockRunnerMoniker = typeof BlockRunnerMoniker
 
+/** Runner interface for executing Block operations. */
 export interface BlockRunner extends BlockRunnerMethods, Provider<BlockRunnerMoniker> {
   next(head: WithHashMeta<BlockBoundWitness>): Promise<SignedHydratedBlockWithHashMeta | undefined>
 }

package/src/runners/Finalization.ts

@@ -3,13 +3,17 @@ import type { Hash } from '@xylabs/sdk-js'
 import type { SignedHydratedBlockWithHashMeta } from '../block/index.ts'
 import type { Provider } from '../provider/index.ts'
 
+/** FinalizationRunnerMethods interface. */
 export interface FinalizationRunnerMethods {
   finalizeBlocks(blocks: SignedHydratedBlockWithHashMeta[]): Promise<Hash[]>
 }
 
+/** Moniker identifier for the FinalizationRunner provider. */
 export const FinalizationRunnerMoniker = 'FinalizationRunner' as const
+/** Type literal for the FinalizationRunner provider moniker. */
 export type FinalizationRunnerMoniker = typeof FinalizationRunnerMoniker
 
+/** Runner interface for executing Finalization operations. */
 export interface FinalizationRunner extends FinalizationRunnerMethods, Provider<FinalizationRunnerMoniker> {
   finalizeBlock(block: SignedHydratedBlockWithHashMeta): Promise<Hash>
 }

package/src/runners/Mempool.ts

@@ -4,22 +4,28 @@ import type { SignedHydratedBlock } from '../block/index.ts'
 import type { SignedHydratedTransaction } from '../model/index.ts'
 import type { Provider } from '../provider/index.ts'
 
+/** MempoolRunnerMethods interface. */
 export interface MempoolRunnerMethods {
   submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]>
   submitTransactions(transactions: SignedHydratedTransaction[]): Promise<Hash[]>
 }
 
+/** Moniker identifier for the MempoolRunner provider. */
 export const MempoolRunnerMoniker = 'MempoolRunner' as const
+/** Type literal for the MempoolRunner provider moniker. */
 export type MempoolRunnerMoniker = typeof MempoolRunnerMoniker
 
+/** DEFAULT_MAX_EXP_AHEAD constant. */
 export const DEFAULT_MAX_EXP_AHEAD = 1000
 
+/** Options for MempoolPrune. */
 export interface MempoolPruneOptions {
   batchSize?: number
   maxCheck?: number
   maxPrune?: number
 }
 
+/** Runner interface for executing Mempool operations. */
 export interface MempoolRunner extends MempoolRunnerMethods, Provider<MempoolRunnerMoniker> {
   prunePendingBlocks(options?: MempoolPruneOptions): Promise<[number, number]>
   prunePendingTransactions(options?: MempoolPruneOptions): Promise<[number, number]>

package/src/transaction/TransactionBoundWitness.ts

@@ -14,120 +14,173 @@ import { XL1BlockNumberZod } from '../BlockNumber/index.ts'
 import { ChainZod } from '../chain/index.ts'
 import { TransactionFeesHexZod } from './TransactionFees.ts'
 
+/** BlockStartZod constant. */
 export const BlockStartZod = z.object({ nbf: XL1BlockNumberZod })
+/** BlockEndZod constant. */
 export const BlockEndZod = z.object({ exp: XL1BlockNumberZod })
+/** BlockDurationZod constant. */
 export const BlockDurationZod = z.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod })
+/** BlockScriptsZod constant. */
 export const BlockScriptsZod = z.object({ script: z.array(z.string()).optional() })
 
+/** TransactionFeesZod constant. */
 export const TransactionFeesZod = z.object({ fees: TransactionFeesHexZod })
 
+/** TransactionBoundWitnessIdentityFields constant. */
 export const TransactionBoundWitnessIdentityFields = z.object({ chain: ChainZod, from: AddressZod })
 
+/** TransactionBoundWitnessFieldsZod constant. */
 export const TransactionBoundWitnessFieldsZod = z.object()
   .safeExtend(BlockDurationZod.shape)
   .safeExtend(TransactionFeesZod.shape)
   .safeExtend(TransactionBoundWitnessIdentityFields.shape)
   .safeExtend(BlockScriptsZod.shape)
 
+/** TransactionBoundWitnessFields type. */
 export type TransactionBoundWitnessFields = z.infer<typeof TransactionBoundWitnessFieldsZod>
 
+/** TransactionBoundWitnessZod constant. */
 export const TransactionBoundWitnessZod = BoundWitnessZod
   .safeExtend(TransactionBoundWitnessFieldsZod.shape)
 
+/** TransactionBoundWitness type. */
 export type TransactionBoundWitness = z.infer<typeof TransactionBoundWitnessZod>
 
+/** Type guard that checks if a value is a valid TransactionBoundWitness. */
 export const isTransactionBoundWitness = zodIsFactory(TransactionBoundWitnessZod)
+/** Converts a value to TransactionBoundWitness, throwing if invalid. */
 export const asTransactionBoundWitness = zodAsFactory(TransactionBoundWitnessZod, 'asTransactionBoundWitness')
+/** toTransactionBoundWitness constant. */
 export const toTransactionBoundWitness = zodToFactory(TransactionBoundWitnessZod, 'toTransactionBoundWitness')
 
+/** TransactionBoundWitnessWithHashMetaZod constant. */
 export const TransactionBoundWitnessWithHashMetaZod = TransactionBoundWitnessZod
   .safeExtend(HashMetaZod.shape)
 
+/** TransactionBoundWitnessWithHashMeta type. */
 export type TransactionBoundWitnessWithHashMeta = z.infer<typeof TransactionBoundWitnessWithHashMetaZod>
 
+/** Type guard that checks if a value is a valid TransactionBoundWitnessWithHashMeta. */
 export const isTransactionBoundWitnessWithHashMeta = zodIsFactory(TransactionBoundWitnessWithHashMetaZod)
+/** Converts a value to TransactionBoundWitnessWithHashMeta, throwing if invalid. */
 export const asTransactionBoundWitnessWithHashMeta = zodAsFactory(TransactionBoundWitnessWithHashMetaZod, 'asTransactionBoundWitnessWithHashMeta')
+/** toTransactionBoundWitnessWithHashMeta constant. */
 export const toTransactionBoundWitnessWithHashMeta = zodToFactory(TransactionBoundWitnessWithHashMetaZod, 'toTransactionBoundWitnessWithHashMeta')
 
+/** TransactionBoundWitnessWithStorageMetaZod constant. */
 export const TransactionBoundWitnessWithStorageMetaZod = TransactionBoundWitnessZod
   .safeExtend(StorageMetaZod.shape)
 
+/** TransactionBoundWitnessWithStorageMeta type. */
 export type TransactionBoundWitnessWithStorageMeta = z.infer<typeof TransactionBoundWitnessWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid TransactionBoundWitnessWithStorageMeta. */
 export const isTransactionBoundWitnessWithStorageMeta = zodIsFactory(TransactionBoundWitnessWithStorageMetaZod)
+/** Converts a value to TransactionBoundWitnessWithStorageMeta, throwing if invalid. */
 export const asTransactionBoundWitnessWithStorageMeta = zodAsFactory(TransactionBoundWitnessWithStorageMetaZod, 'asTransactionBoundWitnessWithStorageMeta')
+/** toTransactionBoundWitnessWithStorageMeta constant. */
 export const toTransactionBoundWitnessWithStorageMeta = zodToFactory(TransactionBoundWitnessWithStorageMetaZod, 'toTransactionBoundWitnessWithStorageMeta')
 
+/** UnsignedTransactionBoundWitnessZod constant. */
 export const UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod
   .safeExtend(TransactionBoundWitnessFieldsZod.shape)
 
+/** UnsignedTransactionBoundWitness type. */
 export type UnsignedTransactionBoundWitness = z.infer<typeof UnsignedTransactionBoundWitnessZod>
 
+/** Type guard that checks if a value is a valid UnsignedTransactionBoundWitness. */
 export const isUnsignedTransactionBoundWitness = zodIsFactory(UnsignedTransactionBoundWitnessZod)
+/** Converts a value to UnsignedTransactionBoundWitness, throwing if invalid. */
 export const asUnsignedTransactionBoundWitness = zodAsFactory(UnsignedTransactionBoundWitnessZod, 'asUnsignedTransactionBoundWitness')
+/** toUnsignedTransactionBoundWitness constant. */
 export const toUnsignedTransactionBoundWitness = zodToFactory(UnsignedTransactionBoundWitnessZod, 'toUnsignedTransactionBoundWitness')
 
+/** UnsignedTransactionBoundWitnessWithHashMetaZod constant. */
 export const UnsignedTransactionBoundWitnessWithHashMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(HashMetaZod.shape)
 
+/** UnsignedTransactionBoundWitnessWithHashMeta type. */
 export type UnsignedTransactionBoundWitnessWithHashMeta = z.infer<typeof UnsignedTransactionBoundWitnessWithHashMetaZod>
 
+/** Type guard that checks if a value is a valid UnsignedTransactionBoundWitnessWithHashMeta. */
 export const isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory(UnsignedTransactionBoundWitnessWithHashMetaZod)
+/** Converts a value to UnsignedTransactionBoundWitnessWithHashMeta, throwing if invalid. */
 export const asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   'asUnsignedTransactionBoundWitnessWithHashMeta',
 )
+/** toUnsignedTransactionBoundWitnessWithHashMeta constant. */
 export const toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   'toUnsignedTransactionBoundWitnessWithHashMeta',
 )
 
+/** UnsignedTransactionBoundWitnessWithStorageMetaZod constant. */
 export const UnsignedTransactionBoundWitnessWithStorageMetaZod = UnsignedTransactionBoundWitnessZod
   .safeExtend(StorageMetaZod.shape)
 
+/** UnsignedTransactionBoundWitnessWithStorageMeta type. */
 export type UnsignedTransactionBoundWitnessWithStorageMeta = z.infer<typeof UnsignedTransactionBoundWitnessWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid UnsignedTransactionBoundWitnessWithStorageMeta. */
 export const isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory(UnsignedTransactionBoundWitnessWithStorageMetaZod)
+/** Converts a value to UnsignedTransactionBoundWitnessWithStorageMeta, throwing if invalid. */
 export const asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   'asUnsignedTransactionBoundWitnessWithStorageMeta',
 )
+/** toUnsignedTransactionBoundWitnessWithStorageMeta constant. */
 export const toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   'toUnsignedTransactionBoundWitnessWithStorageMeta',
 )
 
+/** SignedTransactionBoundWitnessZod constant. */
 export const SignedTransactionBoundWitnessZod = SignedBoundWitnessZod
   .safeExtend(TransactionBoundWitnessFieldsZod.shape)
 
+/** SignedTransactionBoundWitness type. */
 export type SignedTransactionBoundWitness = z.infer<typeof SignedTransactionBoundWitnessZod>
 
+/** Type guard that checks if a value is a valid SignedTransactionBoundWitness. */
 export const isSignedTransactionBoundWitness = zodIsFactory(SignedTransactionBoundWitnessZod)
+/** Converts a value to SignedTransactionBoundWitness, throwing if invalid. */
 export const asSignedTransactionBoundWitness = zodAsFactory(SignedTransactionBoundWitnessZod, 'asSignedTransactionBoundWitness')
+/** toSignedTransactionBoundWitness constant. */
 export const toSignedTransactionBoundWitness = zodToFactory(SignedTransactionBoundWitnessZod, 'toSignedTransactionBoundWitness')
 
+/** SignedTransactionBoundWitnessWithHashMetaZod constant. */
 export const SignedTransactionBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedTransactionBoundWitnessZod)
 
+/** SignedTransactionBoundWitnessWithHashMeta type. */
 export type SignedTransactionBoundWitnessWithHashMeta = z.infer<typeof SignedTransactionBoundWitnessWithHashMetaZod>
 
+/** Type guard that checks if a value is a valid SignedTransactionBoundWitnessWithHashMeta. */
 export const isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory(SignedTransactionBoundWitnessWithHashMetaZod)
+/** Converts a value to SignedTransactionBoundWitnessWithHashMeta, throwing if invalid. */
 export const asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory(
   SignedTransactionBoundWitnessWithHashMetaZod,
   'asSignedTransactionBoundWitnessWithHashMeta',
 )
+/** toSignedTransactionBoundWitnessWithHashMeta constant. */
 export const toSignedTransactionBoundWitnessWithHashMeta = zodToFactory(
   SignedTransactionBoundWitnessWithHashMetaZod,
   'toSignedTransactionBoundWitnessWithHashMeta',
 )
 
+/** SignedTransactionBoundWitnessWithStorageMetaZod constant. */
 export const SignedTransactionBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedTransactionBoundWitnessZod)
 
+/** SignedTransactionBoundWitnessWithStorageMeta type. */
 export type SignedTransactionBoundWitnessWithStorageMeta = z.infer<typeof SignedTransactionBoundWitnessWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid SignedTransactionBoundWitnessWithStorageMeta. */
 export const isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory(SignedTransactionBoundWitnessWithStorageMetaZod)
+/** Converts a value to SignedTransactionBoundWitnessWithStorageMeta, throwing if invalid. */
 export const asSignedTransactionBoundWitnessWithStorageMeta = zodAsFactory(
   SignedTransactionBoundWitnessWithStorageMetaZod,
   'asSignedTransactionBoundWitnessWithStorageMeta',
 )
+/** toSignedTransactionBoundWitnessWithStorageMeta constant. */
 export const toSignedTransactionBoundWitnessWithStorageMeta = zodToFactory(
   SignedTransactionBoundWitnessWithStorageMetaZod,
   'toSignedTransactionBoundWitnessWithStorageMeta',

package/src/transaction/TransactionFees.ts

@@ -6,11 +6,14 @@ import { z } from 'zod'
 
 import { asAttoXL1 } from '../xl1/index.ts'
 
+/** AttoZod constant. */
 export const AttoZod = z.bigint()
+/** JsonToAttoZod constant. */
 export const JsonToAttoZod = JsonToBigIntZod.transform(v => asAttoXL1(v))
-// eslint-disable-next-line unicorn/prefer-export-from
-export const AttoToJsonZod = BigIntToJsonZod
 
+/** AttoToJsonZod constant. */
+
+/** TransactionFeesHexZod constant. */
 export const TransactionFeesHexZod = z.object({
   base: HexZod,
   gasLimit: HexZod,
@@ -18,12 +21,17 @@ export const TransactionFeesHexZod = z.object({
   priority: HexZod,
 })
 
+/** TransactionFeesHex type. */
 export type TransactionFeesHex = z.infer<typeof TransactionFeesHexZod>
 
+/** Type guard that checks if a value is a valid TransactionFeesHex. */
 export const isTransactionFeesHex = zodIsFactory(TransactionFeesHexZod)
+/** Converts a value to TransactionFeesHex, throwing if invalid. */
 export const asTransactionFeesHex = zodAsFactory(TransactionFeesHexZod, 'asTransactionFeesHex')
+/** toTransactionFeesHex constant. */
 export const toTransactionFeesHex = zodToFactory(TransactionFeesHexZod, 'toTransactionFeesHex')
 
+/** TransactionFeesBigIntZod constant. */
 export const TransactionFeesBigIntZod = z.object({
   base: AttoZod,
   gasLimit: AttoZod,
@@ -31,12 +39,17 @@ export const TransactionFeesBigIntZod = z.object({
   priority: AttoZod,
 })
 
+/** TransactionFeesBigInt type. */
 export type TransactionFeesBigInt = z.infer<typeof TransactionFeesBigIntZod>
 
+/** Type guard that checks if a value is a valid TransactionFeesBigInt. */
 export const isTransactionFeesBigInt = zodIsFactory(TransactionFeesBigIntZod)
+/** Converts a value to TransactionFeesBigInt, throwing if invalid. */
 export const asTransactionFeesBigInt = zodAsFactory(TransactionFeesBigIntZod, 'asTransactionFeesBigInt')
+/** toTransactionFeesBigInt constant. */
 export const toTransactionFeesBigInt = zodToFactory(TransactionFeesBigIntZod, 'toTransactionFeesBigInt')
 
+/** TransactionFeesJsonToBigIntZod constant. */
 export const TransactionFeesJsonToBigIntZod = TransactionFeesHexZod.transform(val => ({
   base: JsonToBigIntZod.parse(val.base),
   gasLimit: JsonToBigIntZod.parse(val.gasLimit),
@@ -44,6 +57,7 @@ export const TransactionFeesJsonToBigIntZod = TransactionFeesHexZod.transform(va
   priority: JsonToBigIntZod.parse(val.priority),
 }))
 
+/** TransactionFeesBigIntToJsonZod constant. */
 export const TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform(val => ({
   base: BigIntToJsonZod.parse(val.base),
   gasLimit: BigIntToJsonZod.parse(val.gasLimit),
@@ -51,5 +65,9 @@ export const TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform
   priority: BigIntToJsonZod.parse(val.priority),
 }))
 
+/** TransactionFeesJsonToBigIntZodType type. */
 export type TransactionFeesJsonToBigIntZodType = z.infer<typeof TransactionFeesJsonToBigIntZod>
+/** TransactionFeesBigIntToJsonZodType type. */
 export type TransactionFeesBigIntToJsonZodType = z.infer<typeof TransactionFeesBigIntToJsonZod>
+
+export { BigIntToJsonZod as AttoToJsonZod } from '@xylabs/sdk-js'

package/src/transaction/TransactionGasCosts.ts

@@ -1,3 +1,4 @@
+/** TransactionGasCosts constant. */
 export const TransactionGasCosts = {
   /**
    * The cost of storing each character that is added to the chain

package/src/validation/block/BlockValidationFunction.ts

@@ -5,6 +5,7 @@ import type { ChainId } from '../../chain/index.ts'
 import type { BaseContext } from '../../model/index.ts'
 import type { BlockValidationError } from './error.ts'
 
+/** Function type for BlockValidator operations. */
 export type BlockValidatorFunction = (
   context: BaseContext,
   block: BlockBoundWitness,

package/src/validation/block/HydratedBlockStateValidationFunction.ts

@@ -9,8 +9,10 @@ import type {
 } from '../../model/index.ts'
 import type { HydratedBlockStateValidationError } from './error.ts'
 
+/** Function type for ChainAtBlockNumber operations. */
 export type ChainAtBlockNumberFunction = (blockNumber: XL1BlockNumber) => Promisable<ChainId>
 
+/** Context for HydratedBlockStateValidationFunction operations. */
 export interface HydratedBlockStateValidationFunctionContext extends BaseContext {
   accountBalance: AccountBalanceViewer
   chainIdAtBlockNumber: ChainAtBlockNumberFunction

package/src/validation/block/HydratedBlockValidationFunction.ts

@@ -6,6 +6,7 @@ import type { ChainId } from '../../chain/index.ts'
 import type { BaseContext } from '../../model/index.ts'
 import type { HydratedBlockValidationError } from './error.ts'
 
+/** Context for HydratedBlockValidationFunction operations. */
 export interface HydratedBlockValidationFunctionContext extends BaseContext {}
 
 /**

package/src/validation/block/error.ts

@@ -4,8 +4,10 @@ import type { BlockBoundWitness, HydratedBlock } from '../../block/index.ts'
 import type { ChainId } from '../../chain/index.ts'
 import { isValidationError, ValidationError } from '../error.ts'
 
+/** Error thrown during Blockvalidation  operations. */
 export class BlockValidationError extends ValidationError<BlockBoundWitness> {}
 
+/** Type guard that checks if a value is a valid BlockValidationError. */
 export const isBlockValidationError = (
   error: unknown,
 ): error is BlockValidationError => {
@@ -15,8 +17,10 @@ export const isBlockValidationError = (
   )
 }
 
+/** Error thrown during HydratedBlockvalidation  operations. */
 export class HydratedBlockValidationError extends ValidationError<HydratedBlock> {}
 
+/** Type guard that checks if a value is a valid HydratedBlockValidationError. */
 export const isHydratedBlockValidationError = (
   error: unknown,
 ): error is HydratedBlockValidationError => {
@@ -26,6 +30,7 @@ export const isHydratedBlockValidationError = (
   )
 }
 
+/** Error thrown during HydratedBlockStatevalidation  operations. */
 export class HydratedBlockStateValidationError extends ValidationError<HydratedBlock> {
   chainId: ChainId
   constructor(hash: Hash, chainId: ChainId, value: HydratedBlock, message?: string, cause?: unknown) {
@@ -34,6 +39,7 @@ export class HydratedBlockStateValidationError extends ValidationError<HydratedB
   }
 }
 
+/** Type guard that checks if a value is a valid HydratedBlockStateValidationError. */
 export const isHydratedBlockStateValidationError = (
   error: unknown,
 ): error is HydratedBlockStateValidationError => {

package/src/validation/boundwitness/BoundWitnessValidationFunction.ts

@@ -3,6 +3,7 @@ import type { BoundWitness } from '@xyo-network/sdk-js'
 
 import type { BoundWitnessValidationError } from './error.ts'
 
+/** Function type for BoundWitnessValidation operations. */
 export type BoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (
   bw: T,
 ) => Promisable<BoundWitnessValidationError[]>

package/src/validation/boundwitness/HydratedBoundWitnessValidationFunction.ts

@@ -5,9 +5,11 @@ import type {
 
 import type { HydratedBoundWitnessValidationError } from './error.ts'
 
+/** Type representing a hydrated BoundWitnessWithHashMeta with resolved payloads. */
 export type HydratedBoundWitnessWithHashMeta<T extends BoundWitness = BoundWitness, P extends Payload = Payload>
   = [WithHashMeta<T>, WithHashMeta<P>[]]
 
+/** Type representing a hydrated BoundWitnessValidationFunction with resolved payloads. */
 export type HydratedBoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (
   bw: HydratedBoundWitnessWithHashMeta<T>,
 ) => Promisable<HydratedBoundWitnessValidationError[]>

package/src/validation/boundwitness/error.ts

@@ -2,8 +2,10 @@ import type { BoundWitness, HydratedBoundWitness } from '@xyo-network/sdk-js'
 
 import { isValidationError, ValidationError } from '../error.ts'
 
+/** Error thrown during BoundWitnessvalidation  operations. */
 export class BoundWitnessValidationError extends ValidationError<BoundWitness> {}
 
+/** Type guard that checks if a value is a valid BoundWitnessValidationError. */
 export const isBoundWitnessValidationError = (
   error: unknown,
 ): error is BoundWitnessValidationError => {
@@ -13,8 +15,10 @@ export const isBoundWitnessValidationError = (
   )
 }
 
+/** Error thrown during HydratedBoundWitnessvalidation  operations. */
 export class HydratedBoundWitnessValidationError extends ValidationError<HydratedBoundWitness> {}
 
+/** Type guard that checks if a value is a valid HydratedBoundWitnessValidationError. */
 export const isHydratedBoundWitnessValidationError = (
   error: unknown,
 ): error is HydratedBoundWitnessValidationError => {

package/src/validation/error.ts

@@ -2,6 +2,7 @@ import { type Hash, isHash } from '@xylabs/sdk-js'
 import { isError } from '@xylabs/sdk-js'
 import type { Payload } from '@xyo-network/sdk-js'
 
+/** Error thrown during validation  operations. */
 export class ValidationError<TValue = Payload> extends Error {
   hash: Hash
   value: TValue
@@ -14,6 +15,7 @@ export class ValidationError<TValue = Payload> extends Error {
   }
 }
 
+/** Type guard that checks if a value is a valid ValidationError. */
 export const isValidationError = <TValue = Payload>(
   error: unknown,
 ): error is ValidationError<TValue> => {

package/src/validation/payload/InBlockPayloadValidationFunction.ts

@@ -5,10 +5,12 @@ import type { HydratedBlockWithHashMeta } from '../../block/index.ts'
 import type { BaseContext } from '../../model/index.ts'
 import type { InBlockPayloadValidationError } from './error.ts'
 
+/** Context for InBlockPayloadValidationFunction operations. */
 export interface InBlockPayloadValidationFunctionContext extends BaseContext {
 
 }
 
+/** Function type for InBlockPayloadValidation operations. */
 export type InBlockPayloadValidationFunction = (
   context: InBlockPayloadValidationFunctionContext,
   payload: WithHashMeta<Payload>, block: HydratedBlockWithHashMeta,

package/src/validation/payload/error.ts

@@ -4,6 +4,7 @@ import { type Payload } from '@xyo-network/sdk-js'
 import type { HydratedBlock } from '../../block/index.ts'
 import { isValidationError, ValidationError } from '../error.ts'
 
+/** Error thrown during InBlockPayloadvalidation  operations. */
 export class InBlockPayloadValidationError extends ValidationError<Payload> {
   block: HydratedBlock
   constructor(hash: Hash, block: HydratedBlock, value: Payload, message?: string, cause?: unknown) {
@@ -12,6 +13,7 @@ export class InBlockPayloadValidationError extends ValidationError<Payload> {
   }
 }
 
+/** Type guard that checks if a value is a valid InBlockPayloadValidationError. */
 export const isInBlockPayloadValidationError = (
   error: unknown,
 ): error is InBlockPayloadValidationError => {

package/src/validation/transaction/HydratedTransactionStateValidationFunction.ts

@@ -8,6 +8,7 @@ import type {
 import type { BlockViewer } from '../../viewers/index.ts'
 import type { HydratedTransactionValidationError } from './error.ts'
 
+/** Context for HydratedTransactionStateValidationFunction operations. */
 export interface HydratedTransactionStateValidationFunctionContext extends BaseContext {
   accountBalanceViewer: AccountBalanceViewer
   blockViewer: BlockViewer

package/src/validation/transaction/HydratedTransactionValidationFunction.ts

@@ -5,6 +5,7 @@ import type { BaseContext, HydratedTransactionWithHashMeta } from '../../model/i
 import type { StepIdentity } from '../../Step/index.ts'
 import type { HydratedTransactionValidationError } from './error.ts'
 
+/** Context for HydratedTransactionValidationFunction operations. */
 export interface HydratedTransactionValidationFunctionContext extends BaseContext {
   chainId: ChainId
   step?: StepIdentity

package/src/validation/transaction/error.ts

@@ -1,8 +1,10 @@
 import type { HydratedTransaction } from '../../model/index.ts'
 import { isValidationError, ValidationError } from '../error.ts'
 
+/** Error thrown during HydratedTransactionvalidation  operations. */
 export class HydratedTransactionValidationError extends ValidationError<HydratedTransaction> {}
 
+/** Type guard that checks if a value is a valid HydratedTransactionValidationError. */
 export const isHydratedTransactionValidationError = (
   error: unknown,
 ): error is HydratedTransactionValidationError => {

package/src/viewers/Block.ts

@@ -9,6 +9,7 @@ import type {
 } from '../model/index.ts'
 import type { Provider, ProviderMoniker } from '../provider/index.ts'
 
+/** BlockViewerMethods interface. */
 export interface BlockViewerMethods {
   blocksByHash(hash: Hash, limit?: number): Promisable<SignedHydratedBlockWithHashMeta[]>
   blocksByNumber(block: XL1BlockNumber, limit?: number): Promisable<SignedHydratedBlockWithHashMeta[]>
@@ -16,9 +17,12 @@ export interface BlockViewerMethods {
   payloadsByHash(hashes: Hash[]): Promisable<WithHashMeta<Payload>[]>
 }
 
+/** Moniker identifier for the BlockViewer provider. */
 export const BlockViewerMoniker = 'BlockViewer' as const
+/** Type literal for the BlockViewer provider moniker. */
 export type BlockViewerMoniker = typeof BlockViewerMoniker
 
+/** Viewer interface for reading Block data. */
 export interface BlockViewer<TMoniker extends ProviderMoniker = BlockViewerMoniker> extends BlockViewerMethods, Provider<TMoniker> {
   blockByHash(hash: Hash): Promisable<SignedHydratedBlockWithHashMeta | null>
   blockByNumber(block: XL1BlockNumber): Promisable<SignedHydratedBlockWithHashMeta | null>

package/src/viewers/BlockInvalidation.ts

@@ -9,15 +9,20 @@ import {
 import type { Provider } from '../provider/index.ts'
 import type { HydratedBlockValidationError } from '../validation/index.ts'
 
+/** BlockInvalidationQualificationZod constant. */
 export const BlockInvalidationQualificationZod = ChainQualificationZod
+/** BlockInvalidationQualification type. */
 export type BlockInvalidationQualification = z.infer<typeof BlockInvalidationQualificationZod>
+/** Type guard that checks if a value is a valid BlockInvalidationQualification. */
 export const isBlockInvalidationQualification = zodIsFactory(BlockInvalidationQualificationZod)
 
+/** BlockInvalidationConfigFieldsZod constant. */
 export const BlockInvalidationConfigFieldsZod = z.object({
   state: z.boolean().optional(),
   value: z.boolean().optional(),
 })
 
+/** BlockInvalidationConfigZod constant. */
 export const BlockInvalidationConfigZod = z.union([
   BlockInvalidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
   BlockInvalidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
@@ -25,7 +30,9 @@ export const BlockInvalidationConfigZod = z.union([
   z.object({}),
 ])
 
+/** BlockInvalidationConfig type. */
 export type BlockInvalidationConfig = z.infer<typeof BlockInvalidationConfigZod>
+/** Type guard that checks if a value is a valid BlockInvalidationConfig. */
 export const isBlockInvalidationConfig = zodIsFactory(BlockInvalidationConfigZod)
 
 /**
@@ -44,9 +51,12 @@ export interface BlockInvalidationViewerMethods {
   ): Promisable<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockInvalidationQualification]>
 }
 
+/** Moniker identifier for the BlockInvalidationViewer provider. */
 export const BlockInvalidationViewerMoniker = 'BlockInvalidationViewer' as const
+/** Type literal for the BlockInvalidationViewer provider moniker. */
 export type BlockInvalidationViewerMoniker = typeof BlockInvalidationViewerMoniker
 
+/** Viewer interface for reading BlockInvalidation data. */
 export interface BlockInvalidationViewer extends BlockInvalidationViewerMethods, Provider<BlockInvalidationViewerMoniker> {
   invalidateBlock(
     block: SignedHydratedBlock,

package/src/viewers/BlockReward.ts

@@ -4,12 +4,16 @@ import type { XL1BlockNumber } from '../BlockNumber/index.ts'
 import type { Provider } from '../provider/index.ts'
 import type { AttoXL1 } from '../xl1/index.ts'
 
+/** BlockRewardViewerMethods interface. */
 export interface BlockRewardViewerMethods {
   // The amount of xl1 to send to the producer from the block reward
   allowedRewardForBlock(block: XL1BlockNumber): Promisable<AttoXL1>
 }
 
+/** Moniker identifier for the BlockRewardViewer provider. */
 export const BlockRewardViewerMoniker = 'BlockRewardViewer' as const
+/** Type literal for the BlockRewardViewer provider moniker. */
 export type BlockRewardViewerMoniker = typeof BlockRewardViewerMoniker
 
+/** Viewer interface for reading BlockReward data. */
 export interface BlockRewardViewer extends BlockRewardViewerMethods, Provider<BlockRewardViewerMoniker> {}

package/src/viewers/BlockValidation.ts

@@ -9,15 +9,20 @@ import {
 import type { Provider } from '../provider/index.ts'
 import type { HydratedBlockValidationError } from '../validation/index.ts'
 
+/** BlockValidationQualificationZod constant. */
 export const BlockValidationQualificationZod = ChainQualificationZod
+/** BlockValidationQualification type. */
 export type BlockValidationQualification = z.infer<typeof BlockValidationQualificationZod>
+/** Type guard that checks if a value is a valid BlockValidationQualification. */
 export const isBlockValidationQualification = zodIsFactory(BlockValidationQualificationZod)
 
+/** BlockValidationConfigFieldsZod constant. */
 export const BlockValidationConfigFieldsZod = z.object({
   value: z.boolean().optional(),
   state: z.boolean().optional(),
 })
 
+/** BlockValidationConfigZod constant. */
 export const BlockValidationConfigZod = z.union([
   BlockValidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
   BlockValidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
@@ -25,9 +30,12 @@ export const BlockValidationConfigZod = z.union([
   z.object({}),
 ])
 
+/** BlockValidationConfig type. */
 export type BlockValidationConfig = z.infer<typeof BlockValidationConfigZod>
+/** Type guard that checks if a value is a valid BlockValidationConfig. */
 export const isBlockValidationConfig = zodIsFactory(BlockValidationConfigZod)
 
+/** BlockValidationViewerMethods interface. */
 export interface BlockValidationViewerMethods {
   qualifiedValidateBlocks(
     blocks: SignedHydratedBlock[],
@@ -40,7 +48,9 @@ export interface BlockValidationViewerMethods {
   ): Promisable<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockValidationQualification]>
 }
 
+/** Moniker identifier for the BlockValidationViewer provider. */
 export const BlockValidationViewerMoniker = 'BlockValidationViewer' as const
+/** Type literal for the BlockValidationViewer provider moniker. */
 export type BlockValidationViewerMoniker = typeof BlockValidationViewerMoniker
 
 /**