@xyo-network/xl1-protocol 1.25.33 → 1.26.1

package/src/model/BlockRange/BlockRange.ts

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

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

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

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

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

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

package/src/model/BlockRate.ts

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

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

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

@@ -1,36 +0,0 @@
-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(),
-})

package/src/model/Context/BlockContext.ts

@@ -1,12 +0,0 @@
-import type z from 'zod'
-
-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

@@ -1,20 +0,0 @@
-import type {
-  Payload,
-  ReadArchivist, WriteArchivist,
-} from '@xyo-network/sdk-js'
-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

@@ -1,6 +0,0 @@
-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,4 +0,0 @@
-import { BaseContextZod, CachesZod } from './BaseContext.zod.ts'
-
-/** CachingContextZod constant. */
-export const CachingContextZod = BaseContextZod.extend({ caches: CachesZod })

package/src/model/Context/ChainContext.ts

@@ -1,12 +0,0 @@
-import type z from 'zod'
-
-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

@@ -1,17 +0,0 @@
-import {
-  BlockContextReadZod, BlockContextWriteZod, BlockContextZod,
-} 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

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

@@ -1,13 +0,0 @@
-import { WithHashMetaZod } from '@xyo-network/sdk-js'
-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/Context/index.ts

@@ -1,10 +0,0 @@
-export * from './BaseContext.ts'
-export * from './BaseContext.zod.ts'
-export * from './BlockContext.ts'
-export * from './BlockContext.zod.ts'
-export * from './CachingContext.ts'
-export * from './CachingContext.zod.ts'
-export * from './ChainContext.ts'
-export * from './ChainContext.zod.ts'
-export * from './HeadContext.ts'
-export * from './HeadContext.zod.ts'

package/src/model/GatewayName.ts

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

package/src/model/HydratedTransaction.ts

@@ -1,169 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import {
-  PayloadZod,
-  PayloadZodLoose, WithHashMetaZod,
-  WithStorageMetaZod,
-} from '@xyo-network/sdk-js'
-import { z } from 'zod'
-
-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',
-)