@xyo-network/xl1-protocol-model 1.26.1

package/src/fields/BlockNumber.ts

@@ -0,0 +1,40 @@
+import { AsObjectFactory } from '@xylabs/sdk-js'
+import type { Payload, WithSources } from '@xyo-network/sdk-js'
+import {
+  asSchema,
+  isPayloadOfSchemaType,
+  isPayloadOfSchemaTypeWithSources,
+} from '@xyo-network/sdk-js'
+
+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
+   */
+  block: XL1BlockNumber
+}
+/**
+ * The number of a block
+ */
+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/fields/ChainReference.ts

@@ -0,0 +1,11 @@
+import type { ChainId } from '../chain/index.ts'
+
+/**
+ * Required info for a chain reference
+ */
+export interface ChainReference {
+  /**
+   * The contract address referenced by the chain
+   */
+  chain: ChainId
+}

package/src/fields/index.ts

@@ -0,0 +1,4 @@
+export * from './Addressable.ts'
+export * from './BlockDuration.ts'
+export * from './BlockNumber.ts'
+export * from './ChainReference.ts'

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from './amount/index.ts'
+export * from './block/index.ts'
+export * from './BlockNumber/index.ts'
+export * from './chain/index.ts'
+export * from './fields/index.ts'
+export * from './map/index.ts'
+export * from './model/index.ts'
+export * from './payload/index.ts'
+export * from './provider/index.ts'
+export * from './RecordKeyType.ts'
+export * from './Step/index.ts'
+export * from './transaction/index.ts'
+export * from './TransferPayload.ts'
+export * from './xl1/index.ts'

package/src/map/AsyncMap.ts

@@ -0,0 +1,38 @@
+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[]>
+  has(id: K): Promisable<boolean>
+}
+/**
+ * @deprecated Use AsyncMapRead instead
+ */
+export interface AsynchronousMapRead<K, V> extends AsyncMapRead<K, V> {}
+
+/** AsyncMapWrite interface. */
+export interface AsyncMapWrite<K, V> {
+  clear(): Promisable<void>
+  delete(id: K): Promisable<boolean>
+  set(id: K, data: V): Promisable<K | undefined | void>
+  setMany(entries: [K, V][]): Promisable<K[] | void>
+}
+/**
+ * @deprecated Use AsyncMapWrite instead
+ */
+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

@@ -0,0 +1,27 @@
+import type {
+  AsyncIterableMap, AsyncIterableMapRead, AsyncIterableMapWrite, AsyncMap, AsyncMapRead, AsyncMapWrite,
+} from './AsyncMap.ts'
+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

@@ -0,0 +1,38 @@
+/** SyncMapRead interface. */
+export interface SyncMapRead<K, V> {
+  get(id: K): V | undefined
+  getMany(id: K[]): V[]
+  has(id: K): boolean
+}
+
+/**
+ * @deprecated Use SyncMapRead instead
+ */
+export interface SynchronousMapRead<K, V> extends SyncMapRead<K, V> {}
+
+/** SyncMapWrite interface. */
+export interface SyncMapWrite<K, V> {
+  clear(): void
+  delete(id: K): boolean
+  set(id: K, data: V): K | undefined | void
+  setMany(entries: [K, V][]): K[] | void
+}
+
+/**
+ * @deprecated Use SyncMapWrite instead
+ */
+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/map/index.ts

@@ -0,0 +1,3 @@
+export * from './AsyncMap.ts'
+export * from './MapType.ts'
+export * from './SyncMap.ts'

package/src/model/AccountBalance.ts

@@ -0,0 +1,58 @@
+import { type Address, type Promisable } from '@xylabs/sdk-js'
+import { zodIsFactory } from '@xylabs/sdk-js'
+import { WithHashMetaZod } from '@xyo-network/sdk-js'
+import { z } from 'zod'
+
+import { BlockBoundWitnessZod } from '../block/index.ts'
+import type { Provider } from '../provider/index.ts'
+import { TransactionBoundWitnessZod } from '../transaction/index.ts'
+import { TransferZod } from '../TransferPayload.ts'
+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[],
+    config: AccountBalanceConfig
+  ): Promisable<ChainQualified<Record<Address, AccountBalanceHistoryItem[]>>>
+  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[]>>
+  accountBalanceHistory(address: Address, config?: AccountBalanceConfig): Promisable<AccountBalanceHistoryItem[]>
+  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

@@ -0,0 +1,44 @@
+import { z } from 'zod'
+
+function base64Encode(u8: Uint8Array): string {
+  // Node
+  if (typeof Buffer !== 'undefined' && typeof Buffer.from === 'function') {
+    return Buffer.from(u8).toString('base64')
+  }
+
+  // Browser
+  let binary = ''
+  const chunk = 0x80_00
+  for (let i = 0; i < u8.length; i += chunk) {
+    // eslint-disable-next-line unicorn/prefer-code-point
+    binary += String.fromCharCode(...u8.subarray(i, i + chunk))
+  }
+  return btoa(binary)
+}
+
+/** Base64 decode that works in Node and browsers -> Uint8Array */
+function base64Decode(b64: string): Uint8Array {
+  // Node
+  if (typeof Buffer !== 'undefined' && typeof Buffer.from === 'function') {
+    return new Uint8Array(Buffer.from(b64, 'base64'))
+  }
+
+  // Browser
+  const binary = atob(b64)
+  const u8 = new Uint8Array(binary.length)
+  // eslint-disable-next-line unicorn/prefer-code-point
+  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i)
+  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

@@ -0,0 +1,43 @@
+import type { AssertConfig, Brand } from '@xylabs/sdk-js'
+import {
+  assertError,
+  isDefined, zodAsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+import {
+  asBlockNumber,
+  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
+  return assertError(result, assert, `Invalid BlockRangeKey: ${key}`)
+}

package/src/model/BlockRange/EthBlockRange.ts

@@ -0,0 +1,43 @@
+import type { AssertConfig, Brand } from '@xylabs/sdk-js'
+import {
+  assertError,
+  isDefined, zodAsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+import {
+  asEthBlockNumber,
+  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
+  return assertError(result, assert, `Invalid EthBlockRangeKey: ${key}`)
+}

package/src/model/BlockRange/Numberish.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,17 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} 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

@@ -0,0 +1,43 @@
+import type { AssertConfig, Brand } from '@xylabs/sdk-js'
+import {
+  assertError,
+  isDefined, zodAsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+import {
+  asXL1BlockNumber,
+  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
+  return assertError(result, assert, `Invalid XL1BlockRangeKey: ${key}`)
+}

package/src/model/BlockRange/index.ts

@@ -0,0 +1,4 @@
+export * from './BlockRange.ts'
+export * from './EthBlockRange.ts'
+export * from './Range.ts'
+export * from './XL1BlockRange.ts'

package/src/model/BlockRate.ts

@@ -0,0 +1,108 @@
+import { zodAsFactory, zodIsFactory } from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+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(),
+  minutes: z.number().nonnegative(),
+  hours: z.number().nonnegative(),
+  days: z.number().nonnegative(),
+  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'),
+  timeUnit: TimeDurationsZod.keyof().describe('the unit of time for the rate and timePerBlock'),
+  span: z.int().nonnegative().describe('number of blocks the rate was calculated over'),
+  timeDifference: z.number().nonnegative().describe('time difference from start and end block'),
+  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(),
+  days: timeUnitSchema.optional(),
+  weeks: timeUnitSchema.optional(),
+  months: timeUnitSchema.optional(),
+  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 }),
+  z.object({ days: timeUnitSchema }),
+  z.object({ weeks: timeUnitSchema }),
+  z.object({ months: timeUnitSchema }),
+  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

@@ -0,0 +1,48 @@
+import { HashZod, zodIsFactory } from '@xylabs/sdk-js'
+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),
+    ChainQualifiedHeadConfigZod.extend(zodType),
+    zodType,
+  ])
+}) 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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,36 @@
+import type { MeterProvider, TracerProvider } from '@opentelemetry/api'
+import type { Logger } from '@xylabs/sdk-js'
+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(),
+  meterProvider: MeterProviderZod.optional(),
+  singletons: SingletonsZod,
+  timeBudgetLimit: TimeBudgetLimitZod.optional(),
+  traceProvider: TracerProviderZod.optional(),
+})