@xyo-network/xl1-protocol 1.25.26 → 1.25.28

package/src/model/BlockRate.ts

@@ -5,6 +5,7 @@ import type { EthBlockNumber, XL1BlockNumber } from '../BlockNumber/index.ts'
 import { StepSizes } from '../Step/index.ts'
 import { XL1BlockRangeZod } from './BlockRange/index.ts'
 
+/** TimeDurationsZod constant. */
 export const TimeDurationsZod = z.object({
   millis: z.number().nonnegative(),
   seconds: z.number().nonnegative(),
@@ -14,12 +15,17 @@ export const TimeDurationsZod = z.object({
   weeks: z.number().nonnegative(),
 })
 
+/** Type guard that checks if a value is a valid TimeDurations. */
 export const isTimeDurations = zodIsFactory(TimeDurationsZod)
+/** Converts a value to TimeDurations, throwing if invalid. */
 export const asTimeDurations = zodAsFactory(TimeDurationsZod, 'asTimeDurations')
+/** toTimeDurations constant. */
 export const toTimeDurations = zodAsFactory(TimeDurationsZod, 'toTimeDurations')
 
+/** TimeDurations type. */
 export type TimeDurations = z.infer<typeof TimeDurationsZod>
 
+/** BlockRateZod constant. */
 export const BlockRateZod = z.object({
   range: XL1BlockRangeZod.describe('the block range the rate was calculated over'),
   rate: z.number().nonnegative().describe('rate of blocks per specified time unit'),
@@ -29,27 +35,39 @@ export const BlockRateZod = z.object({
   timePerBlock: z.number().nonnegative().describe('average time per block for the given range'),
 })
 
+/** BlockRate type. */
 export type BlockRate = z.infer<typeof BlockRateZod>
 
+/** GenericBlockRate type. */
 export type GenericBlockRate<TBlockNumber extends number> = Omit<BlockRate, 'range'> & {
   range: [TBlockNumber, TBlockNumber]
 }
 
+/** XL1BlockRate interface. */
 export interface XL1BlockRate extends GenericBlockRate<XL1BlockNumber> {}
+/** EthBlockRate interface. */
 export interface EthBlockRate extends GenericBlockRate<EthBlockNumber> {}
 
+/** Type guard that checks if a value is a valid BlockRate. */
 export const isBlockRate = zodIsFactory(BlockRateZod)
+/** Converts a value to BlockRate, throwing if invalid. */
 export const asBlockRate = zodAsFactory(BlockRateZod, 'asBlockRate')
+/** toBlockRate constant. */
 export const toBlockRate = zodAsFactory(BlockRateZod, 'toBlockRate')
 
+/** CountZod constant. */
 export const CountZod = z.int().nonnegative().describe('A non-negative integer count')
+/** Count type. */
 export type Count = z.infer<typeof CountZod>
 
+/** StepIndexZod constant. */
 export const StepIndexZod = z.int().min(0).max(StepSizes.length).describe('A non-negative integer step index')
+/** StepIndex type. */
 export type StepIndex = z.infer<typeof StepIndexZod>
 
 const timeUnitSchema = z.number().positive()
 
+/** TimeConfigZod constant. */
 export const TimeConfigZod = z.object({
   minutes: timeUnitSchema.optional(),
   hours: timeUnitSchema.optional(),
@@ -59,12 +77,17 @@ export const TimeConfigZod = z.object({
   years: timeUnitSchema.optional(),
 }).describe('Time configuration with optional time units')
 
+/** TimeConfig type. */
 export type TimeConfig = z.infer<typeof TimeConfigZod>
 
+/** Type guard that checks if a value is a valid TimeConfig. */
 export const isTimeConfig = zodIsFactory(TimeConfigZod)
+/** Converts a value to TimeConfig, throwing if invalid. */
 export const asTimeConfig = zodAsFactory(TimeConfigZod, 'asTimeConfig')
+/** toTimeConfig constant. */
 export const toTimeConfig = zodAsFactory(TimeConfigZod, 'toTimeConfig')
 
+/** SingleTimeConfigZod constant. */
 export const SingleTimeConfigZod = z.union([
   z.object({ minutes: timeUnitSchema }),
   z.object({ hours: timeUnitSchema }),
@@ -74,8 +97,12 @@ export const SingleTimeConfigZod = z.union([
   z.object({ years: timeUnitSchema }),
 ]).describe('Time configuration with exactly one time unit')
 
+/** SingleTimeConfig type. */
 export type SingleTimeConfig = z.infer<typeof SingleTimeConfigZod>
 
+/** Type guard that checks if a value is a valid SingleTimeConfig. */
 export const isSingleTimeConfig = zodIsFactory(SingleTimeConfigZod)
+/** Converts a value to SingleTimeConfig, throwing if invalid. */
 export const asSingleTimeConfig = zodAsFactory(SingleTimeConfigZod, 'asSingleTimeConfig')
+/** toSingleTimeConfig constant. */
 export const toSingleTimeConfig = zodAsFactory(SingleTimeConfigZod, 'toSingleTimeConfig')

package/src/model/ChainQualification.ts

@@ -3,22 +3,35 @@ import { z } from 'zod'
 
 import { XL1BlockRangeZod } from './BlockRange/index.ts'
 
+/** ChainQualificationZod constant. */
 export const ChainQualificationZod = z.object({ head: HashZod, range: XL1BlockRangeZod })
+/** ChainQualification type. */
 export type ChainQualification = z.infer<typeof ChainQualificationZod>
+/** Type guard that checks if a value is a valid ChainQualification. */
 export const isChainQualification = zodIsFactory(ChainQualificationZod)
 
+/** ChainQualifiedRangeConfigZod constant. */
 export const ChainQualifiedRangeConfigZod = z.object({ range: XL1BlockRangeZod })
+/** ChainQualifiedRangeConfig type. */
 export type ChainQualifiedRangeConfig = z.infer<typeof ChainQualifiedRangeConfigZod>
+/** Type guard that checks if a value is a valid ChainQualifiedRangeConfig. */
 export const isChainQualifiedRangeConfig = zodIsFactory(ChainQualifiedRangeConfigZod)
 
+/** ChainQualifiedHeadConfigZod constant. */
 export const ChainQualifiedHeadConfigZod = z.object({ head: HashZod })
+/** ChainQualifiedHeadConfig type. */
 export type ChainQualifiedHeadConfig = z.infer<typeof ChainQualifiedHeadConfigZod>
+/** Type guard that checks if a value is a valid ChainQualifiedHeadConfig. */
 export const isChainQualifiedHeadConfig = zodIsFactory(ChainQualifiedHeadConfigZod)
 
+/** ChainQualifiedConfigZod constant. */
 export const ChainQualifiedConfigZod = z.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z.object({})])
+/** ChainQualifiedConfig type. */
 export type ChainQualifiedConfig = z.infer<typeof ChainQualifiedConfigZod>
+/** Type guard that checks if a value is a valid ChainQualifiedConfig. */
 export const isChainQualifiedConfig = zodIsFactory(ChainQualifiedConfigZod)
 
+/** ExtendChainQualifiedConfigZod constant. */
 export const ExtendChainQualifiedConfigZod = (<T>(zodType: z.ZodType<T>) => {
   return z.union([
     ChainQualifiedRangeConfigZod.extend(zodType),
@@ -27,7 +40,9 @@ export const ExtendChainQualifiedConfigZod = (<T>(zodType: z.ZodType<T>) => {
   ])
 }) as <T>(zodType: z.ZodType<T>) => z.ZodType<T & ChainQualifiedConfig>
 
+/** ChainQualified type. */
 export type ChainQualified<T> = [T, ChainQualification]
+/** ChainQualifiedZod constant. */
 export const ChainQualifiedZod = <T>(zodType: z.ZodType<T>) => {
   return z.tuple([zodType, ChainQualificationZod])
 }

package/src/model/Context/BaseContext.ts

@@ -2,4 +2,5 @@ import type z from 'zod'
 
 import type { BaseContextZod } from './BaseContext.zod.ts'
 
+/** BaseContext type. */
 export type BaseContext = z.infer<typeof BaseContextZod>

package/src/model/Context/BaseContext.zod.ts

@@ -4,21 +4,28 @@ import { z } from 'zod'
 
 import type { MapType } from '../../map/index.ts'
 
+/** CachesZod constant. */
 export const CachesZod = z.record(
   z.string(),
   z.custom<MapType<string, unknown>>(val => val && typeof val === 'object' && ('get' in val || 'set' in val)),
 )
 
+/** SingletonsZod constant. */
 export const SingletonsZod = z.record(z.union([z.string(), z.symbol()]), z.unknown())
 
+/** LoggerZod constant. */
 export const LoggerZod = z.custom<Logger>(val => val && typeof val === 'object' && 'info' in val && 'error' in val)
 
+/** MeterProviderZod constant. */
 export const MeterProviderZod = z.custom<MeterProvider>(val => val && typeof val === 'object' && 'getMeter' in val)
 
+/** TracerProviderZod constant. */
 export const TracerProviderZod = z.custom<TracerProvider>(val => val && typeof val === 'object' && 'getTracer' in val)
 
+/** TimeBudgetLimitZod constant. */
 export const TimeBudgetLimitZod = z.number()
 
+/** BaseContextZod constant. */
 export const BaseContextZod = z.object({
   caches: CachesZod.optional(),
   logger: LoggerZod.optional(),

package/src/model/Context/BlockContext.ts

@@ -4,6 +4,9 @@ import type {
   BlockContextReadZod, BlockContextWriteZod, BlockContextZod,
 } from './BlockContext.zod.ts'
 
+/** BlockContextRead type. */
 export type BlockContextRead = z.infer<typeof BlockContextReadZod>
+/** BlockContextWrite type. */
 export type BlockContextWrite = z.infer<typeof BlockContextWriteZod>
+/** BlockContext type. */
 export type BlockContext = z.infer<typeof BlockContextZod>

package/src/model/Context/BlockContext.zod.ts

@@ -6,12 +6,15 @@ import z from 'zod'
 
 import { CachingContextZod } from './CachingContext.zod.ts'
 
+/** BlockContextReadZod constant. */
 export const BlockContextReadZod = CachingContextZod.extend(
   { chainMap: z.custom<ReadArchivist<Payload>>(val => val && typeof val === 'object' && ('get' in val)) },
 )
 
+/** BlockContextWriteZod constant. */
 export const BlockContextWriteZod = CachingContextZod.extend(
   { chainMap: z.custom<WriteArchivist<Payload>>(val => val && typeof val === 'object' && ('get' in val && 'insert' in val)) },
 )
 
+/** BlockContextZod constant. */
 export const BlockContextZod = BlockContextWriteZod

package/src/model/Context/CachingContext.ts

@@ -2,4 +2,5 @@ import type z from 'zod'
 
 import type { CachingContextZod } from './CachingContext.zod.ts'
 
+/** CachingContext type. */
 export type CachingContext = z.infer<typeof CachingContextZod>

package/src/model/Context/CachingContext.zod.ts

@@ -1,3 +1,4 @@
 import { BaseContextZod, CachesZod } from './BaseContext.zod.ts'
 
+/** CachingContextZod constant. */
 export const CachingContextZod = BaseContextZod.extend({ caches: CachesZod })

package/src/model/Context/ChainContext.ts

@@ -4,6 +4,9 @@ import type {
   ChainContextReadZod, ChainContextWriteZod, ChainContextZod,
 } from './ChainContext.zod.ts'
 
+/** ChainContextRead type. */
 export type ChainContextRead = z.infer<typeof ChainContextReadZod>
+/** ChainContextWrite type. */
 export type ChainContextWrite = z.infer<typeof ChainContextWriteZod>
+/** ChainContext type. */
 export type ChainContext = z.infer<typeof ChainContextZod>

package/src/model/Context/ChainContext.zod.ts

@@ -3,12 +3,15 @@ import {
 } from './BlockContext.zod.ts'
 import { HeadContextBaseZod } from './HeadContext.zod.ts'
 
+/** ChainContextReadZod constant. */
 export const ChainContextReadZod = BlockContextReadZod.safeExtend(HeadContextBaseZod.shape)
 
+/** ChainContextWriteZod constant. */
 export const ChainContextWriteZod = BlockContextWriteZod.safeExtend(
   HeadContextBaseZod.shape,
 )
 
+/** ChainContextZod constant. */
 export const ChainContextZod = BlockContextZod.safeExtend(
   HeadContextBaseZod.shape,
 )

package/src/model/Context/HeadContext.ts

@@ -2,4 +2,5 @@ import type z from 'zod'
 
 import type { HeadContextZod } from './HeadContext.zod.ts'
 
+/** HeadContext type. */
 export type HeadContext = z.infer<typeof HeadContextZod>

package/src/model/Context/HeadContext.zod.ts

@@ -4,8 +4,10 @@ import z from 'zod'
 import { BlockBoundWitnessZod } from '../../block/index.ts'
 import { CachingContextZod } from './CachingContext.zod.ts'
 
+/** HeadContextBaseZod constant. */
 export const HeadContextBaseZod = z.object(
   { head: WithHashMetaZod(BlockBoundWitnessZod) },
 )
 
+/** HeadContextZod constant. */
 export const HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape)

package/src/model/GatewayName.ts

@@ -1,3 +1,4 @@
 import type { Brand } from '@xylabs/sdk-js'
 
+/** GatewayName type. */
 export type GatewayName = Brand<string, { __gatewayName: true }>

package/src/model/HydratedTransaction.ts

@@ -12,112 +12,157 @@ import {
   SignedTransactionBoundWitnessZod, TransactionBoundWitnessZod, UnsignedTransactionBoundWitnessZod,
 } from '../transaction/index.ts'
 
+/** HydratedTransactionZod constant. */
 export const HydratedTransactionZod = z.tuple([
   TransactionBoundWitnessZod,
   z.array(PayloadZodLoose),
 ])
 
+/** Type representing a hydrated Transaction with resolved payloads. */
 export type HydratedTransaction = z.infer<typeof HydratedTransactionZod>
 
+/** Type guard that checks if a value is a valid HydratedTransaction. */
 export const isHydratedTransaction = zodIsFactory(HydratedTransactionZod)
+/** Converts a value to HydratedTransaction, throwing if invalid. */
 export const asHydratedTransaction = zodAsFactory(HydratedTransactionZod, 'asHydratedTransaction')
+/** toHydratedTransaction constant. */
 export const toHydratedTransaction = zodToFactory(HydratedTransactionZod, 'toHydratedTransaction')
 
+/** HydratedTransactionWithHashMetaZod constant. */
 export const HydratedTransactionWithHashMetaZod = z.tuple([
   WithHashMetaZod(TransactionBoundWitnessZod),
   z.array(WithHashMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated TransactionWithHashMeta with resolved payloads. */
 export type HydratedTransactionWithHashMeta = z.infer<typeof HydratedTransactionWithHashMetaZod>
 
+/** Type guard that checks if a value is a valid HydratedTransactionWithHashMeta. */
 export const isHydratedTransactionWithHashMeta = zodIsFactory(HydratedTransactionWithHashMetaZod)
+/** Converts a value to HydratedTransactionWithHashMeta, throwing if invalid. */
 export const asHydratedTransactionWithHashMeta = zodAsFactory(HydratedTransactionWithHashMetaZod, 'asHydratedTransactionWithHashMeta')
+/** toHydratedTransactionWithHashMeta constant. */
 export const toHydratedTransactionWithHashMeta = zodToFactory(HydratedTransactionWithHashMetaZod, 'toHydratedTransactionWithHashMeta')
 
+/** HydratedTransactionWithStorageMetaZod constant. */
 export const HydratedTransactionWithStorageMetaZod = z.tuple([
   WithStorageMetaZod(TransactionBoundWitnessZod),
   z.array(WithStorageMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated TransactionWithStorageMeta with resolved payloads. */
 export type HydratedTransactionWithStorageMeta = z.infer<typeof HydratedTransactionWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid HydratedTransactionWithStorageMeta. */
 export const isHydratedTransactionWithStorageMeta = zodIsFactory(HydratedTransactionWithStorageMetaZod)
+/** Converts a value to HydratedTransactionWithStorageMeta, throwing if invalid. */
 export const asHydratedTransactionWithStorageMeta = zodAsFactory(HydratedTransactionWithStorageMetaZod, 'asHydratedTransactionWithStorageMeta')
+/** toHydratedTransactionWithStorageMeta constant. */
 export const toHydratedTransactionWithStorageMeta = zodToFactory(HydratedTransactionWithStorageMetaZod, 'toHydratedTransactionWithStorageMeta')
 
+/** UnsignedHydratedTransactionZod constant. */
 export const UnsignedHydratedTransactionZod = z.tuple([
   UnsignedTransactionBoundWitnessZod,
   z.array(PayloadZodLoose),
 ])
 
+/** Type representing a hydrated UnsignedTransaction with resolved payloads. */
 export type UnsignedHydratedTransaction = z.infer<typeof UnsignedHydratedTransactionZod>
 
+/** Type guard that checks if a value is a valid UnsignedHydratedTransaction. */
 export const isUnsignedHydratedTransaction = zodIsFactory(UnsignedHydratedTransactionZod)
+/** Converts a value to UnsignedHydratedTransaction, throwing if invalid. */
 export const asUnsignedHydratedTransaction = zodAsFactory(UnsignedHydratedTransactionZod, 'asUnsignedHydratedTransaction')
+/** toUnsignedHydratedTransaction constant. */
 export const toUnsignedHydratedTransaction = zodToFactory(UnsignedHydratedTransactionZod, 'toUnsignedHydratedTransaction')
 
+/** UnsignedHydratedTransactionWithHashMetaZod constant. */
 export const UnsignedHydratedTransactionWithHashMetaZod = z.tuple([
   WithHashMetaZod(UnsignedTransactionBoundWitnessZod),
   z.array(WithHashMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated UnsignedTransactionWithHashMeta with resolved payloads. */
 export type UnsignedHydratedTransactionWithHashMeta = z.infer<typeof UnsignedHydratedTransactionWithHashMetaZod>
 
+/** Type guard that checks if a value is a valid UnsignedHydratedTransactionWithHashMeta. */
 export const isUnsignedHydratedTransactionWithHashMeta = zodIsFactory(UnsignedHydratedTransactionWithHashMetaZod)
+/** Converts a value to UnsignedHydratedTransactionWithHashMeta, throwing if invalid. */
 export const asUnsignedHydratedTransactionWithHashMeta = zodAsFactory(UnsignedHydratedTransactionWithHashMetaZod, 'asUnsignedHydratedTransactionWithHashMeta')
+/** toUnsignedHydratedTransactionWithHashMeta constant. */
 export const toUnsignedHydratedTransactionWithHashMeta = zodToFactory(UnsignedHydratedTransactionWithHashMetaZod, 'toUnsignedHydratedTransactionWithHashMeta')
 
+/** UnsignedHydratedTransactionWithStorageMetaZod constant. */
 export const UnsignedHydratedTransactionWithStorageMetaZod = z.tuple([
   WithStorageMetaZod(UnsignedTransactionBoundWitnessZod),
   z.array(WithStorageMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated UnsignedTransactionWithStorageMeta with resolved payloads. */
 export type UnsignedHydratedTransactionWithStorageMeta = z.infer<typeof UnsignedHydratedTransactionWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid UnsignedHydratedTransactionWithStorageMeta. */
 export const isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory(UnsignedHydratedTransactionWithStorageMetaZod)
+/** Converts a value to UnsignedHydratedTransactionWithStorageMeta, throwing if invalid. */
 export const asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory(
   UnsignedHydratedTransactionWithStorageMetaZod,
   'asUnsignedHydratedTransactionWithStorageMeta',
 )
+/** toUnsignedHydratedTransactionWithStorageMeta constant. */
 export const toUnsignedHydratedTransactionWithStorageMeta = zodToFactory(
   UnsignedHydratedTransactionWithStorageMetaZod,
   'toUnsignedHydratedTransactionWithStorageMeta',
 )
 
+/** SignedHydratedTransactionZod constant. */
 export const SignedHydratedTransactionZod = z.tuple([
   SignedTransactionBoundWitnessZod,
   z.array(PayloadZodLoose),
 ])
 
+/** Type representing a hydrated SignedTransaction with resolved payloads. */
 export type SignedHydratedTransaction = z.infer<typeof SignedHydratedTransactionZod>
 
+/** Type guard that checks if a value is a valid SignedHydratedTransaction. */
 export const isSignedHydratedTransaction = zodIsFactory(SignedHydratedTransactionZod)
+/** Converts a value to SignedHydratedTransaction, throwing if invalid. */
 export const asSignedHydratedTransaction = zodAsFactory(SignedHydratedTransactionZod, 'asSignedHydratedTransaction')
+/** toSignedHydratedTransaction constant. */
 export const toSignedHydratedTransaction = zodToFactory(SignedHydratedTransactionZod, 'toSignedHydratedTransaction')
 
+/** SignedHydratedTransactionWithHashMetaZod constant. */
 export const SignedHydratedTransactionWithHashMetaZod = z.tuple([
   WithHashMetaZod(SignedTransactionBoundWitnessZod),
   z.array(WithHashMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated SignedTransactionWithHashMeta with resolved payloads. */
 export type SignedHydratedTransactionWithHashMeta = z.infer<typeof SignedHydratedTransactionWithHashMetaZod>
 
+/** Type guard that checks if a value is a valid SignedHydratedTransactionWithHashMeta. */
 export const isSignedHydratedTransactionWithHashMeta = zodIsFactory(SignedHydratedTransactionWithHashMetaZod)
+/** Converts a value to SignedHydratedTransactionWithHashMeta, throwing if invalid. */
 export const asSignedHydratedTransactionWithHashMeta = zodAsFactory(SignedHydratedTransactionWithHashMetaZod, 'asSignedHydratedTransactionWithHashMeta')
+/** toSignedHydratedTransactionWithHashMeta constant. */
 export const toSignedHydratedTransactionWithHashMeta = zodToFactory(SignedHydratedTransactionWithHashMetaZod, 'toSignedHydratedTransactionWithHashMeta')
 
+/** SignedHydratedTransactionWithStorageMetaZod constant. */
 export const SignedHydratedTransactionWithStorageMetaZod = z.tuple([
   WithStorageMetaZod(SignedTransactionBoundWitnessZod),
   z.array(WithStorageMetaZod(PayloadZod).loose()),
 ])
 
+/** Type representing a hydrated SignedTransactionWithStorageMeta with resolved payloads. */
 export type SignedHydratedTransactionWithStorageMeta = z.infer<typeof SignedHydratedTransactionWithStorageMetaZod>
 
+/** Type guard that checks if a value is a valid SignedHydratedTransactionWithStorageMeta. */
 export const isSignedHydratedTransactionWithStorageMeta = zodIsFactory(SignedHydratedTransactionWithStorageMetaZod)
+/** Converts a value to SignedHydratedTransactionWithStorageMeta, throwing if invalid. */
 export const asSignedHydratedTransactionWithStorageMeta = zodAsFactory(
   SignedHydratedTransactionWithStorageMetaZod,
   'asSignedHydratedTransactionWithStorageMeta',
 )
+/** toSignedHydratedTransactionWithStorageMeta constant. */
 export const toSignedHydratedTransactionWithStorageMeta = zodToFactory(
   SignedHydratedTransactionWithStorageMetaZod,
   'toSignedHydratedTransactionWithStorageMeta',

package/src/model/OpCodes.ts

@@ -1 +1,2 @@
+/** ELEVATE_OPCODE constant. */
 export const ELEVATE_OPCODE = 'elevate'

package/src/model/PayloadMap.ts

@@ -5,6 +5,9 @@ import type {
   MapType, MapTypeRead, MapTypeWrite,
 } from '../map/index.ts'
 
+/** PayloadMapWrite type. */
 export type PayloadMapWrite<T extends Payload = Payload> = MapTypeWrite<Hash, T>
+/** PayloadMapRead type. */
 export type PayloadMapRead<T extends Payload = Payload> = MapTypeRead<Hash, T>
+/** PayloadMap type. */
 export type PayloadMap<T extends Payload = Payload> = MapType<Hash, T>

package/src/model/Permission.ts

@@ -1,22 +1,28 @@
 import { z } from 'zod'
 
+/** CaveatTypesZod constant. */
 export const CaveatTypesZod = z.enum(['chain', 'expiration', 'filteredResponse', 'rateLimit', 'restrictReturnedAccounts'])
 
+/** CaveatsZod constant. */
 export const CaveatsZod = z.object({
   type: CaveatTypesZod,
   value: z.json(),
 })
 
+/** PermissionZod constant. */
 export const PermissionZod = z.object({
   parentCapability: z.string(),
   caveats: CaveatsZod.array().optional(),
   invoker: z.string(),
 })
 
+/** InvokerPermissionZod constant. */
 export const InvokerPermissionZod = PermissionZod.safeExtend({ date: z.number().optional() })
 
+/** PermissionRequestZod constant. */
 export const PermissionRequestZod = z.record(z.string(), z.record(z.string(), z.any()))
 
+/** RequestedPermissionZod constant. */
 export const RequestedPermissionZod = z.object({
   parentCapability: z.string(),
   date: z.number().optional(),

package/src/model/Position.ts

@@ -2,6 +2,7 @@ import type { Address } from '@xylabs/sdk-js'
 
 import type { PositionId } from './PositionId.ts'
 
+/** Position type. */
 export type Position = {
   // the block number when the stake was added
   addBlock: number

package/src/model/PositionId.ts

@@ -1,3 +1,4 @@
 import type { Brand } from '@xylabs/sdk-js'
 
+/** PositionId type. */
 export type PositionId = Brand<number, { readonly __positionId: true }>

package/src/model/RangeMultipliers.ts

@@ -2,8 +2,12 @@ import type {
   BlockRangeKey, EthBlockRangeKey, XL1BlockRangeKey,
 } from './BlockRange/index.ts'
 
+/** BigFraction type. */
 export type BigFraction = [bigint, bigint] // numerator, denominator
 
+/** RangeMultipliers type. */
 export type RangeMultipliers = Record<BlockRangeKey, BigFraction>
+/** EthRangeMultipliers type. */
 export type EthRangeMultipliers = Record<EthBlockRangeKey, BigFraction>
+/** XL1RangeMultipliers type. */
 export type XL1RangeMultipliers = Record<XL1BlockRangeKey, BigFraction>

package/src/model/RewardShare.ts

@@ -1 +1,2 @@
+/** RewardShare type. */
 export type RewardShare = [bigint, bigint] // [share, total]

package/src/model/RewardsRangeOptions.ts

@@ -4,6 +4,7 @@ import { z } from 'zod'
 import { StepIdentityZod } from '../Step/index.ts'
 import { BlockRangeZod } from './BlockRange/index.ts'
 
+/** RewardsRangeOptionsZod constant. */
 export const RewardsRangeOptionsZod = z.object({
   positions: z.array(z.number()).optional(),
   range: BlockRangeZod.optional(),

package/src/model/Sequence.ts

@@ -4,12 +4,18 @@ import { SequenceConstants } from '@xyo-network/sdk-js'
 import { z } from 'zod'
 
 const LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes))
+/** LocalSequenceToStringZod constant. */
 export const LocalSequenceToStringZod = z.string().regex(LocalSequenceRegex)
+/** LocalSequenceFromStringZod constant. */
 export const LocalSequenceFromStringZod = z.string().regex(LocalSequenceRegex).transform<LocalSequence>(v => toHex(v) as LocalSequence)
 
 const QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes))
+/** QualifiedSequenceToStringZod constant. */
 export const QualifiedSequenceToStringZod = z.string().regex(QualifiedSequenceRegex)
+/** QualifiedSequenceFromStringZod constant. */
 export const QualifiedSequenceFromStringZod = z.string().regex(QualifiedSequenceRegex).transform<QualifiedSequence>(v => toHex(v) as QualifiedSequence)
 
+/** SequenceToStringZod constant. */
 export const SequenceToStringZod = z.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod])
+/** SequenceFromStringZod constant. */
 export const SequenceFromStringZod = z.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod])

package/src/model/Stake.ts

@@ -6,6 +6,7 @@ import {
 } from '../transaction/index.ts'
 import type { PositionId } from './PositionId.ts'
 
+/** StakeZod constant. */
 export const StakeZod = z.object({
   amount: AttoZod,
   // the block number when the stake was added
@@ -22,6 +23,7 @@ export const StakeZod = z.object({
   withdrawBlock: z.number(),
 })
 
+/** StakeToJsonZod constant. */
 export const StakeToJsonZod = StakeZod.transform(val => ({
   addBlock: val.addBlock,
   amount: AttoToJsonZod.parse(val.amount),
@@ -33,6 +35,7 @@ export const StakeToJsonZod = StakeZod.transform(val => ({
 }))
 
 // we intentionally use extend and not safeExtend here to ensure all fields are present
+/** JsonToStakeZod constant. */
 export const JsonToStakeZod = StakeZod.extend({ amount: HexZod }).transform(val => ({
   addBlock: val.addBlock,
   amount: JsonToAttoZod.parse(val.amount),

package/src/model/StakeShare.ts

@@ -1 +1,2 @@
+/** StakeShare type. */
 export type StakeShare = [bigint, bigint] // [share, total]

package/src/model/TimeDomain.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod'
 
+/** TimeDomainZod constant. */
 export const TimeDomainZod = z.union([
   z.literal('xl1'),
   z.literal('epoch'),

package/src/model/TransferPair.ts

@@ -1,6 +1,7 @@
 import { AddressZod } from '@xylabs/sdk-js'
 import { z } from 'zod'
 
+/** TransferPairZod constant. */
 export const TransferPairZod = z.tuple([
   AddressZod, AddressZod,
 ])

package/src/model/addresses.ts

@@ -20,12 +20,17 @@ export const XYO_NETWORK_STAKING_ADDRESS = '196919691969196919691969196919691969
  */
 export const XYO_STEP_REWARD_ADDRESS = '1216197612161976121619761216197612161976' as const as Address
 
+/** XL1_ETH_MAIN_ERC20_CONTRACT_ADDRESS constant. */
 export const XL1_ETH_MAIN_ERC20_CONTRACT_ADDRESS = '0xf72aE3E0DA743033AbD7A407557D684c1aE66aed' as const as EthAddress
 
+/** XL1_ETH_MAIN_SUB_GOVERNOR_ADDRESS constant. */
 export const XL1_ETH_MAIN_SUB_GOVERNOR_ADDRESS = '0xbA296Bc5D0949C0484f08c56c30FB95CC4675A29' as const as EthAddress
 
+/** XL1_ETH_MAIN_REWARDS_ADDRESS constant. */
 export const XL1_ETH_MAIN_REWARDS_ADDRESS = '0x1a546e091FB4EFb274DC584334a28b8754c4ece7' as const as EthAddress
 
+/** XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS constant. */
 export const XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS = '0x319e667cED10452A117472811130444dED357F26' as const as EthAddress
 
+/** XL1_ETH_MAIN_GOVERNANCE_ADDRESS constant. */
 export const XL1_ETH_MAIN_GOVERNANCE_ADDRESS = '0x7595710956d6B14b4f2F51a8dF41379eEeC9074E' as const as EthAddress

package/src/model/defaultRewardRatio.ts

@@ -1,2 +1,3 @@
 // the percent of the block rewards the producer gets
+/** defaultRewardRatio value. */
 export const defaultRewardRatio = 0.05 as const // 5.0% goes to block producer

package/src/model/defaultTransactionFees.ts

@@ -2,6 +2,7 @@ import type { TransactionFeesBigInt } from '../transaction/index.ts'
 import { AttoXL1, AttoXL1ConvertFactor } from '../xl1/index.ts'
 import { minTransactionFees } from './minTransactionFees.ts'
 
+/** defaultTransactionFees value. */
 export const defaultTransactionFees: TransactionFeesBigInt = {
   base: minTransactionFees.base,
   gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),

package/src/model/minTransactionFees.ts

@@ -1,6 +1,7 @@
 import type { TransactionFeesBigInt } from '../transaction/index.ts'
 import { AttoXL1, AttoXL1ConvertFactor } from '../xl1/index.ts'
 
+/** minTransactionFees value. */
 export const minTransactionFees: TransactionFeesBigInt = {
   base: AttoXL1(1000n * AttoXL1ConvertFactor.nano),
   gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),

package/src/model/rewards.ts

@@ -2,10 +2,17 @@ import { toFixedPoint } from '@xylabs/sdk-js'
 
 import { asAttoXL1 } from '../xl1/index.ts'
 
+/** XL1_REWARDS_PLACES constant. */
 export const XL1_REWARDS_PLACES = 18 as const
+/** XL1_REWARDS_STARTING_REWARD constant. */
 export const XL1_REWARDS_STARTING_REWARD = asAttoXL1(toFixedPoint(500n, XL1_REWARDS_PLACES))
+/** XL1_REWARDS_BLOCKS_PER_STEP constant. */
 export const XL1_REWARDS_BLOCKS_PER_STEP = 1_000_000
+/** XL1_REWARDS_STEP_FACTOR_NUMERATOR constant. */
 export const XL1_REWARDS_STEP_FACTOR_NUMERATOR = 95n
+/** XL1_REWARDS_STEP_FACTOR_DENOMINATOR constant. */
 export const XL1_REWARDS_STEP_FACTOR_DENOMINATOR = 100n
+/** XL1_REWARDS_MIN_BLOCK_REWARD constant. */
 export const XL1_REWARDS_MIN_BLOCK_REWARD = asAttoXL1(toFixedPoint(10n, XL1_REWARDS_PLACES))
+/** XL1_REWARDS_CREATOR_REWARD constant. */
 export const XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20_000_000_000n, XL1_REWARDS_PLACES))