@xyo-network/xl1-protocol-model 1.26.11 → 1.26.13

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',
-)

package/src/model/OpCodes.ts

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

package/src/model/PayloadMap.ts

@@ -1,13 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-
-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,29 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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
-  // the amount that is staked
-  amount: bigint
-  // the unique id for the stake item
-  id: PositionId
-  // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: number
-  // the address that is being staked
-  staked: Address
-  // the address that owns the stake
-  staker: Address
-  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: number
-}

package/src/model/PositionId.ts

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

package/src/model/RangeMultipliers.ts

@@ -1,13 +0,0 @@
-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,2 +0,0 @@
-/** RewardShare type. */
-export type RewardShare = [bigint, bigint] // [share, total]

package/src/model/RewardsRangeOptions.ts

@@ -1,13 +0,0 @@
-import { AddressZod } from '@xylabs/sdk-js'
-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(),
-  steps: z.array(StepIdentityZod).optional(),
-  stakers: z.array(AddressZod).optional(),
-})

package/src/model/Sequence.ts

@@ -1,21 +0,0 @@
-import { HexRegExMinMax, toHex } from '@xylabs/sdk-js'
-import type { LocalSequence, QualifiedSequence } from '@xyo-network/sdk-js'
-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])