@xyo-network/xl1-protocol-model 1.26.1

package/src/Step/StepIdentity.ts

@@ -0,0 +1,46 @@
+import { type Brand, isUndefined } from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+import { toXL1BlockNumber, XL1BlockNumberZod } from '../BlockNumber/index.ts'
+
+/** Zod schema for a step identity combining a block number and step index */
+export const StepIdentityZod = z.object({
+  block: XL1BlockNumberZod.describe('The block number at which the step occurs'),
+  step: z.number().int().nonnegative().describe('The index of the step into the StepSize array'),
+})
+/** Identifies a specific step by its block number and step index */
+export type StepIdentity = z.infer<typeof StepIdentityZod>
+
+/** @deprecated use StepIdentity instead */
+export interface StepContext extends StepIdentity {}
+
+/** Branded string representing a block number and step index separated by a pipe character */
+export type StepIdentityString = Brand<string, { readonly __stepIdentityString: true }>
+
+function tryParseInt(value: string): number | undefined {
+  // Prevent coercion of empty strings to 0
+  if (value === '') return undefined
+  // Parse number
+  const num = Number(value)
+  // Check if integer
+  return Number.isInteger(num) ? num : undefined
+}
+
+/** Parses a pipe-separated string into a StepIdentity, returning undefined if invalid */
+export const asStepIdentity = (stepIdentityString: string): StepIdentity | undefined => {
+  try {
+    const [blockNumberString, stepString] = stepIdentityString.split('|')
+    if (isUndefined(blockNumberString) || isUndefined(stepString)) {
+      return undefined
+    }
+    const step = tryParseInt(stepString)
+    const block = toXL1BlockNumber(blockNumberString)
+    if (isUndefined(block) || isUndefined(step)) {
+      return undefined
+    }
+
+    return { block, step }
+  } catch {
+    return undefined
+  }
+}

package/src/Step/StepSizes.ts

@@ -0,0 +1,47 @@
+import { AsTypeFactory } from '@xylabs/sdk-js'
+
+import { asXL1BlockNumber, type XL1BlockNumber } from '../BlockNumber/index.ts'
+
+// StepsV2 are primorial(n+2) + 1, where n is the index of the step size
+// primorial(n+2) = 2 → 2×3=6 → 6×5=30 → 30×7=210 → 210×11=2310
+
+/** Array of step sizes based on primorial(n+2) + 1, defining the block intervals for each step level */
+export const StepSizes: XL1BlockNumber[] = [
+  asXL1BlockNumber(7, true),
+  asXL1BlockNumber(31, true),
+  asXL1BlockNumber(211, true),
+  asXL1BlockNumber(2311, true),
+  asXL1BlockNumber(30_031, true),
+  asXL1BlockNumber(510_511, true),
+  asXL1BlockNumber(9_699_691, true),
+  asXL1BlockNumber(223_092_871, true),
+  asXL1BlockNumber(6_469_693_231, true),
+]
+
+/** Type guard that checks if a value is a valid step index within the StepSizes array */
+export function isValidStep(step: unknown): step is number {
+  if (typeof step === 'number' && Number.isInteger(step)) {
+    return ((step >= 0) && (step < StepSizes.length))
+  }
+  return false
+}
+
+/** Casts a value to a valid step index, returning undefined if invalid */
+export const asValidStep = AsTypeFactory.create<number>(isValidStep)
+
+/** Returns the block interval size for a given step index */
+export function stepSize(step: number): number {
+  const validatedStep = asValidStep(step, () => `Invalid step (${step}), must be an integer between 0 and ${StepSizes.length - 1}`, { required: true })
+  return StepSizes[validatedStep]
+}
+
+/** Fraction of block rewards allocated at each step level, expressed as [numerator, denominator] pairs */
+export const StepRewardFractions = [
+  [0n, 1n], // 0%
+  [0n, 1n], // 0%
+  [0n, 1n], // 0%
+  [1n, 10_000n], // 0.01%
+  [2n, 1000n], // 0.2%
+  [3n, 100n], // 3%
+  [45n, 100n], // 45%
+] as const

package/src/Step/index.ts

@@ -0,0 +1,3 @@
+export * from './StepHash.ts'
+export * from './StepIdentity.ts'
+export * from './StepSizes.ts'

package/src/TransferPayload.ts

@@ -0,0 +1,35 @@
+import {
+  AddressZod,
+  AsObjectFactory, HexZod, JsonObjectZod,
+} from '@xylabs/sdk-js'
+import {
+  asSchema, isPayloadOfSchemaType, PayloadZodOfSchema,
+} from '@xyo-network/sdk-js'
+import { z } from 'zod'
+
+/** Schema identifier for XYO transfer payloads */
+export const TransferSchema = asSchema('network.xyo.transfer', true)
+/** The literal type of the transfer schema string */
+export type TransferSchema = typeof TransferSchema
+
+/** Zod schema for the fields specific to a transfer payload */
+export const TransferFieldsZod = z.object({
+  // Removed as only transaction have opCodes
+  // $opCodes: z.array(z.string()).optional(),
+  context: JsonObjectZod.optional(),
+  epoch: z.number(),
+  from: AddressZod,
+  transfers: z.record(AddressZod, HexZod),
+})
+
+/** Zod schema for a complete transfer payload including schema and fields */
+export const TransferZod = PayloadZodOfSchema(TransferSchema).extend(TransferFieldsZod.shape)
+
+/** A transfer payload representing the movement of XL1 tokens between addresses */
+export type Transfer = z.infer<typeof TransferZod>
+
+/** Type guard that checks if a value is a Transfer payload */
+export const isTransfer = isPayloadOfSchemaType<Transfer>(TransferSchema)
+
+/** Casts a value to Transfer or returns undefined if invalid */
+export const asTransfer = AsObjectFactory.create(isTransfer)

package/src/amount/ShiftedBigIntConfig.ts

@@ -0,0 +1,8 @@
+/** Configuration for formatting a ShiftedBigInt as a decimal string */
+export interface ShiftedBigIntConfig {
+  locale: Intl.LocalesArgument
+  maxCharacters: number
+  maxDecimal: number
+  minDecimals: number
+  places: number
+}

package/src/amount/XL1AmountInstance.ts

@@ -0,0 +1,19 @@
+import type {
+  AttoXL1, FemtoXL1, MicroXL1, MilliXL1, NanoXL1, PicoXL1, XL1,
+} from '../xl1/index.ts'
+import type { ShiftedBigIntConfig } from './ShiftedBigIntConfig.ts'
+
+/** Interface for an XL1 token amount with conversion accessors for various denominations */
+export interface XL1AmountInstance {
+  atto: AttoXL1
+  femto: FemtoXL1
+  micro: MicroXL1
+  milli: MilliXL1
+  nano: NanoXL1
+  pico: PicoXL1
+  value: AttoXL1
+  xl1: XL1
+
+  to(places: bigint | number): bigint
+  toString(places: number, config: Partial<ShiftedBigIntConfig>): string
+}

package/src/amount/index.ts

@@ -0,0 +1,2 @@
+export * from './ShiftedBigIntConfig.ts'
+export * from './XL1AmountInstance.ts'

package/src/block/AllowedBlockPayload.ts

@@ -0,0 +1,73 @@
+import { zodIsFactory } from '@xylabs/sdk-js'
+import type {
+  Schema, SchemaPayload, WithStorageMeta,
+} from '@xyo-network/sdk-js'
+import {
+  BoundWitnessSchema, isHashMeta, isSchemaPayload, SchemaSchema,
+} from '@xyo-network/sdk-js'
+import { z } from 'zod'
+
+import type {
+  BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation, ChainStakeIntent, HashPayload, StepComplete, TimePayload,
+} from '../payload/index.ts'
+import {
+  BridgeDestinationObservationSchema, BridgeIntentSchema, BridgeSourceObservationSchema, ChainStakeIntentSchema, HashSchema,
+  isBridgeDestinationObservation, isBridgeIntent, isBridgeSourceObservation, isChainStakeIntent, isHashPayload, isTimePayload, StepCompleteSchema,
+  TimeSchema,
+} from '../payload/index.ts'
+import { isTransactionBoundWitness, type TransactionBoundWitness } from '../transaction/index.ts'
+import {
+  isTransfer, type Transfer, TransferSchema,
+} from '../TransferPayload.ts'
+
+/** AllowedBlockPayload type. */
+export type AllowedBlockPayload
+  = | BridgeDestinationObservation
+    | BridgeIntent
+    | BridgeSourceObservation
+    | ChainStakeIntent
+    | HashPayload
+    | SchemaPayload
+    | StepComplete
+    | TimePayload
+    | TransactionBoundWitness
+    | Transfer
+
+/** AllowedBlockPayloadSchemas constant. */
+export const AllowedBlockPayloadSchemas = [
+  BoundWitnessSchema,
+  BridgeDestinationObservationSchema,
+  BridgeIntentSchema,
+  BridgeSourceObservationSchema,
+  ChainStakeIntentSchema,
+  HashSchema,
+  SchemaSchema,
+  StepCompleteSchema,
+  TimeSchema,
+  TransferSchema,
+] satisfies Schema[]
+
+/** AllowedBlockPayloadSchemaZod constant. */
+export const AllowedBlockPayloadSchemaZod = z.enum(AllowedBlockPayloadSchemas)
+/** Schema type for AllowedBlockPayload payloads. */
+export type AllowedBlockPayloadSchema = z.infer<typeof AllowedBlockPayloadSchemaZod>
+/** Schema identifier for isAllowedBlockPayload payloads. */
+export const isAllowedBlockPayloadSchema = zodIsFactory(AllowedBlockPayloadSchemaZod)
+
+/** Type guard that checks if a value is a valid AllowedBlockPayload. */
+export const isAllowedBlockPayload = <T>(value: T): value is AllowedBlockPayload & T => {
+  return isTransfer(value)
+    || isBridgeDestinationObservation(value)
+    || isBridgeIntent(value)
+    || isBridgeSourceObservation(value)
+    || isChainStakeIntent(value)
+    || isHashPayload(value)
+    || isSchemaPayload(value)
+    || isTimePayload(value)
+    || isTransactionBoundWitness(value)
+}
+
+/** Type guard that checks if a value is a valid AllowedBlockPayloadWithHashMeta. */
+export const isAllowedBlockPayloadWithHashMeta = <T>(value: T): value is WithStorageMeta<AllowedBlockPayload & T> => {
+  return isAllowedBlockPayload(value) && isHashMeta(value)
+}

package/src/block/BlockBoundWitness.ts

@@ -0,0 +1,72 @@
+import {
+  HashZod,
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import {
+  BoundWitnessZod,
+  WithHashMetaZod,
+  WithStorageMetaZod,
+} from '@xyo-network/sdk-js'
+import { z } from 'zod'
+
+import { XL1BlockNumberZod } from '../BlockNumber/index.ts'
+import { ChainZod } from '../chain/index.ts'
+
+/** BlockBoundWitnessFieldsZod constant. */
+export const BlockBoundWitnessFieldsZod = z.object({
+  block: XL1BlockNumberZod,
+  chain: ChainZod,
+  previous: HashZod.nullable(),
+  protocol: z.number().optional(),
+  step_hashes: z.array(HashZod).optional(),
+})
+
+/** BlockBoundWitnessMetaZod constant. */
+export const BlockBoundWitnessMetaZod = z.object({ $epoch: z.number() })
+
+/** BlockBoundWitnessZod constant. */
+export const BlockBoundWitnessZod = z.object({
+  ...BoundWitnessZod.shape,
+  ...BlockBoundWitnessFieldsZod.shape,
+  ...BlockBoundWitnessMetaZod.shape,
+})
+
+/** BlockBoundWitness type. */
+export type BlockBoundWitness = z.infer<typeof BlockBoundWitnessZod>
+
+/** Type guard that checks if a value is a valid BlockBoundWitness. */
+export const isBlockBoundWitness = zodIsFactory(BlockBoundWitnessZod)
+/** Converts a value to BlockBoundWitness, throwing if invalid. */
+export const asBlockBoundWitness = zodAsFactory(BlockBoundWitnessZod, 'asBlockBoundWitness')
+/** toBlockBoundWitness constant. */
+export const toBlockBoundWitness = zodToFactory(BlockBoundWitnessZod, 'toBlockBoundWitness')
+
+/** @deprecated use WithHashMetaZod(BlockBoundWitnessZod) instead */
+export const BlockBoundWitnessWithHashMetaZod = WithHashMetaZod(BlockBoundWitnessZod)
+
+/** @deprecated use WithHashMeta(BlockBoundWitness) instead */
+
+/** BlockBoundWitnessWithHashMeta type. */
+export type BlockBoundWitnessWithHashMeta = z.infer<typeof BlockBoundWitnessWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid BlockBoundWitnessWithHashMeta. */
+export const isBlockBoundWitnessWithHashMeta = zodIsFactory(WithHashMetaZod(BlockBoundWitnessZod))
+/** Converts a value to BlockBoundWitnessWithHashMeta, throwing if invalid. */
+export const asBlockBoundWitnessWithHashMeta = zodAsFactory(WithHashMetaZod(BlockBoundWitnessZod), 'asBlockBoundWitnessWithHashMeta')
+/** toBlockBoundWitnessWithHashMeta constant. */
+export const toBlockBoundWitnessWithHashMeta = zodToFactory(WithHashMetaZod(BlockBoundWitnessZod), 'toBlockBoundWitnessWithHashMeta')
+
+/** @deprecated use WithStorageMetaZod(BlockBoundWitnessZod) instead */
+export const BlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod(BlockBoundWitnessZod)
+
+/** @deprecated use WithStorageMeta(BlockBoundWitness) instead */
+
+/** BlockBoundWitnessWithStorageMeta type. */
+export type BlockBoundWitnessWithStorageMeta = z.infer<typeof BlockBoundWitnessWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid BlockBoundWitnessWithStorageMeta. */
+export const isBlockBoundWitnessWithStorageMeta = zodIsFactory(WithStorageMetaZod(BlockBoundWitnessZod))
+/** Converts a value to BlockBoundWitnessWithStorageMeta, throwing if invalid. */
+export const asBlockBoundWitnessWithStorageMeta = zodAsFactory(WithStorageMetaZod(BlockBoundWitnessZod), 'asBlockBoundWitnessWithStorageMeta')
+/** toBlockBoundWitnessWithStorageMeta constant. */
+export const toBlockBoundWitnessWithStorageMeta = zodToFactory(WithStorageMetaZod(BlockBoundWitnessZod), 'toBlockBoundWitnessWithStorageMeta')

package/src/block/HydratedBlock.ts

@@ -0,0 +1,135 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import {
+  PayloadZod,
+  PayloadZodLoose, WithHashMetaZod, WithStorageMetaZod,
+} from '@xyo-network/sdk-js'
+import { z } from 'zod'
+
+import { BlockBoundWitnessZod } from './BlockBoundWitness.ts'
+import { SignedBlockBoundWitnessZod } from './signed/index.ts'
+
+/** HydratedBlockZod constant. */
+export const HydratedBlockZod = z.tuple([
+  BlockBoundWitnessZod,
+  z.array(PayloadZodLoose),
+])
+
+/** Type representing a hydrated Block with resolved payloads. */
+export type HydratedBlock = z.infer<typeof HydratedBlockZod>
+
+/** Type guard that checks if a value is a valid HydratedBlock. */
+export const isHydratedBlock = zodIsFactory(HydratedBlockZod)
+/** Converts a value to HydratedBlock, throwing if invalid. */
+export const asHydratedBlock = zodAsFactory(HydratedBlockZod, 'asHydratedBlock')
+/** toHydratedBlock constant. */
+export const toHydratedBlock = zodToFactory(HydratedBlockZod, 'toHydratedBlock')
+
+/** HydratedBlockWithHashMetaZod constant. */
+export const HydratedBlockWithHashMetaZod = z.tuple([
+  WithHashMetaZod(BlockBoundWitnessZod),
+  z.array(WithHashMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated BlockWithHashMeta with resolved payloads. */
+export type HydratedBlockWithHashMeta = z.infer<typeof HydratedBlockWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid HydratedBlockWithHashMeta. */
+export const isHydratedBlockWithHashMeta = zodIsFactory(HydratedBlockWithHashMetaZod)
+/** Converts a value to HydratedBlockWithHashMeta, throwing if invalid. */
+export const asHydratedBlockWithHashMeta = zodAsFactory(HydratedBlockWithHashMetaZod, 'asHydratedBlockWithHashMeta')
+/** toHydratedBlockWithHashMeta constant. */
+export const toHydratedBlockWithHashMeta = zodToFactory(HydratedBlockWithHashMetaZod, 'toHydratedBlockWithHashMeta')
+
+/** HydratedBlockWithStorageMetaZod constant. */
+export const HydratedBlockWithStorageMetaZod = z.tuple([
+  WithStorageMetaZod(BlockBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated BlockWithStorageMeta with resolved payloads. */
+export type HydratedBlockWithStorageMeta = z.infer<typeof HydratedBlockWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid HydratedBlockWithStorageMeta. */
+export const isHydratedBlockWithStorageMeta = zodIsFactory(HydratedBlockWithStorageMetaZod)
+/** Converts a value to HydratedBlockWithStorageMeta, throwing if invalid. */
+export const asHydratedBlockWithStorageMeta = zodAsFactory(HydratedBlockWithStorageMetaZod, 'asHydratedBlockWithStorageMeta')
+/** toHydratedBlockWithStorageMeta constant. */
+export const toHydratedBlockWithStorageMeta = zodToFactory(HydratedBlockWithStorageMetaZod, 'toHydratedBlockWithStorageMeta')
+
+/** SignedHydratedBlockZod constant. */
+export const SignedHydratedBlockZod = z.tuple([
+  SignedBlockBoundWitnessZod,
+  z.array(PayloadZod.loose()),
+])
+
+/** Type representing a hydrated SignedBlock with resolved payloads. */
+export type SignedHydratedBlock = z.infer<typeof SignedHydratedBlockZod>
+
+/** Type guard that checks if a value is a valid SignedHydratedBlock. */
+export const isSignedHydratedBlock = zodIsFactory(SignedHydratedBlockZod)
+/** Converts a value to SignedHydratedBlock, throwing if invalid. */
+export const asSignedHydratedBlock = zodAsFactory(SignedHydratedBlockZod, 'asSignedHydratedBlock')
+/** toSignedHydratedBlock constant. */
+export const toSignedHydratedBlock = zodToFactory(SignedHydratedBlockZod, 'toSignedHydratedBlock')
+
+/** SignedHydratedBlockToJsonZod constant. */
+export const SignedHydratedBlockToJsonZod = z.tuple([
+  SignedBlockBoundWitnessZod,
+  z.array(PayloadZod.loose()),
+])
+
+/** Type representing a hydrated SignedBlockToJson with resolved payloads. */
+export type SignedHydratedBlockToJson = z.infer<typeof SignedHydratedBlockToJsonZod>
+
+/** Type guard that checks if a value is a valid SignedHydratedBlockToJson. */
+export const isSignedHydratedBlockToJson = zodIsFactory(SignedHydratedBlockToJsonZod)
+/** Converts a value to SignedHydratedBlockToJson, throwing if invalid. */
+export const asSignedHydratedBlockToJson = zodAsFactory(SignedHydratedBlockToJsonZod, 'asSignedHydratedBlockToJson')
+/** toSignedHydratedBlockToJson constant. */
+export const toSignedHydratedBlockToJson = zodToFactory(SignedHydratedBlockToJsonZod, 'toSignedHydratedBlockToJson')
+
+/** SignedHydratedBlockWithHashMetaZod constant. */
+export const SignedHydratedBlockWithHashMetaZod = z.tuple([
+  WithHashMetaZod(SignedBlockBoundWitnessZod),
+  z.array(WithHashMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated SignedBlockWithHashMeta with resolved payloads. */
+export type SignedHydratedBlockWithHashMeta = z.infer<typeof SignedHydratedBlockWithHashMetaZod>
+
+/** SignedHydratedBlockWithHashMetaishZod constant. */
+export const SignedHydratedBlockWithHashMetaishZod = z.tuple([
+  z.union([WithHashMetaZod(SignedBlockBoundWitnessZod)]),
+  z.array(WithHashMetaZod(PayloadZod).loose()),
+])
+
+/** Type guard that checks if a value is a valid SignedHydratedBlockWithHashMeta. */
+export const isSignedHydratedBlockWithHashMeta = zodIsFactory(SignedHydratedBlockWithHashMetaZod)
+/** Converts a value to SignedHydratedBlockWithHashMeta, throwing if invalid. */
+export const asSignedHydratedBlockWithHashMeta = zodAsFactory(SignedHydratedBlockWithHashMetaZod, 'asSignedHydratedBlockWithHashMeta')
+
+/** toSignedHydratedBlockWithHashMeta constant. */
+export const toSignedHydratedBlockWithHashMeta = zodToFactory(SignedHydratedBlockWithHashMetaZod, 'toSignedHydratedBlockWithHashMeta')
+
+/** SignedHydratedBlockWithStorageMetaZod constant. */
+export const SignedHydratedBlockWithStorageMetaZod = z.tuple([
+  WithStorageMetaZod(SignedBlockBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZod).loose()),
+])
+/** Type representing a hydrated SignedBlockWithStorageMeta with resolved payloads. */
+export type SignedHydratedBlockWithStorageMeta = z.infer<typeof SignedHydratedBlockWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid SignedHydratedBlockWithStorageMeta. */
+export const isSignedHydratedBlockWithStorageMeta = zodIsFactory(SignedHydratedBlockWithStorageMetaZod)
+/** Converts a value to SignedHydratedBlockWithStorageMeta, throwing if invalid. */
+export const asSignedHydratedBlockWithStorageMeta = zodAsFactory(SignedHydratedBlockWithStorageMetaZod, 'asSignedHydratedBlockWithStorageMeta')
+/** toSignedHydratedBlockWithStorageMeta constant. */
+export const toSignedHydratedBlockWithStorageMeta = zodToFactory(SignedHydratedBlockWithStorageMetaZod, 'toSignedHydratedBlockWithStorageMeta')
+
+/** SignedHydratedBlockWithStorageMetaishZod constant. */
+export const SignedHydratedBlockWithStorageMetaishZod = z.tuple([
+  z.union([WithStorageMetaZod(SignedBlockBoundWitnessZod)]),
+  z.array(WithStorageMetaZod(PayloadZod).loose()),
+])

package/src/block/index.ts

@@ -0,0 +1,5 @@
+export * from './AllowedBlockPayload.ts'
+export * from './BlockBoundWitness.ts'
+export * from './HydratedBlock.ts'
+export * from './signed/index.ts'
+export * from './unsigned/index.ts'

package/src/block/signed/SignedBlockBoundWitness.ts

@@ -0,0 +1,22 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import { SignedBoundWitnessZod } from '@xyo-network/sdk-js'
+import type { z } from 'zod'
+
+import { BlockBoundWitnessFieldsZod, BlockBoundWitnessMetaZod } from '../BlockBoundWitness.ts'
+
+/** SignedBlockBoundWitnessZod constant. */
+export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
+  .safeExtend(BlockBoundWitnessFieldsZod.shape)
+  .safeExtend(BlockBoundWitnessMetaZod.shape)
+
+/** SignedBlockBoundWitness type. */
+export type SignedBlockBoundWitness = z.infer<typeof SignedBlockBoundWitnessZod>
+
+/** Type guard that checks if a value is a valid SignedBlockBoundWitness. */
+export const isSignedBlockBoundWitness = zodIsFactory(SignedBlockBoundWitnessZod)
+/** Converts a value to SignedBlockBoundWitness, throwing if invalid. */
+export const asSignedBlockBoundWitness = zodAsFactory(SignedBlockBoundWitnessZod, 'asSignedBlockBoundWitness')
+/** toSignedBlockBoundWitness constant. */
+export const toSignedBlockBoundWitness = zodToFactory(SignedBlockBoundWitnessZod, 'toSignedBlockBoundWitness')

package/src/block/signed/SignedBlockBoundWitnessWithHashMeta.ts

@@ -0,0 +1,35 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import { PayloadBuilder, WithHashMetaZod } from '@xyo-network/sdk-js'
+import type { z } from 'zod'
+
+import { isSignedBlockBoundWitness, SignedBlockBoundWitnessZod } from './SignedBlockBoundWitness.ts'
+
+/** SignedBlockBoundWitnessWithHashMetaZod constant. */
+export const SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedBlockBoundWitnessZod)
+
+/** SignedBlockBoundWitnessWithHashMeta type. */
+export type SignedBlockBoundWitnessWithHashMeta = z.infer<typeof SignedBlockBoundWitnessWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid SignedBlockBoundWitnessWithHashMeta. */
+export const isSignedBlockBoundWitnessWithHashMeta = zodIsFactory(SignedBlockBoundWitnessWithHashMetaZod)
+/** Converts a value to SignedBlockBoundWitnessWithHashMeta, throwing if invalid. */
+export const asSignedBlockBoundWitnessWithHashMeta = zodAsFactory(SignedBlockBoundWitnessWithHashMetaZod, 'asSignedBlockBoundWitnessWithHashMeta')
+
+/** SignedBlockBoundWitnessWithHashMetaishZod constant. */
+export const SignedBlockBoundWitnessWithHashMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
+  if (isSignedBlockBoundWitnessWithHashMeta(data)) {
+    return data
+  }
+  if (isSignedBlockBoundWitness(data)) {
+    return await PayloadBuilder.addHashMeta(data)
+  }
+  throw new Error('Invalid SignedBlockBoundWitnessWithHashMetaish format')
+})
+
+/** SignedBlockBoundWitnessWithHashMetaish type. */
+export type SignedBlockBoundWitnessWithHashMetaish = z.input<typeof SignedBlockBoundWitnessWithHashMetaishZod>
+
+/** toSignedBlockBoundWitnessWithHashMeta constant. */
+export const toSignedBlockBoundWitnessWithHashMeta = zodToFactory(SignedBlockBoundWitnessWithHashMetaZod, 'toSignedBlockBoundWitnessWithHashMeta')

package/src/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts

@@ -0,0 +1,41 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import { PayloadBuilder, WithStorageMetaZod } from '@xyo-network/sdk-js'
+import type { z } from 'zod'
+
+import { isSignedBlockBoundWitness, SignedBlockBoundWitnessZod } from './SignedBlockBoundWitness.ts'
+
+/** SignedBlockBoundWitnessWithStorageMetaZod constant. */
+export const SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedBlockBoundWitnessZod)
+
+/** SignedBlockBoundWitnessWithStorageMeta type. */
+export type SignedBlockBoundWitnessWithStorageMeta = z.infer<typeof SignedBlockBoundWitnessWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid SignedBlockBoundWitnessWithStorageMeta. */
+export const isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory(SignedBlockBoundWitnessWithStorageMetaZod)
+/** Converts a value to SignedBlockBoundWitnessWithStorageMeta, throwing if invalid. */
+export const asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory(
+  SignedBlockBoundWitnessWithStorageMetaZod,
+  'asSignedBlockBoundWitnessWithStorageMeta',
+)
+
+/** SignedBlockBoundWitnessWithStorageMetaishZod constant. */
+export const SignedBlockBoundWitnessWithStorageMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
+  if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
+    return data
+  }
+  if (isSignedBlockBoundWitness(data)) {
+    return await PayloadBuilder.addStorageMeta(data)
+  }
+  throw new Error('Invalid SignedBlockBoundWitnessWithStorageMetaish format')
+})
+
+/** SignedBlockBoundWitnessWithStorageMetaish type. */
+export type SignedBlockBoundWitnessWithStorageMetaish = z.input<typeof SignedBlockBoundWitnessWithStorageMetaishZod>
+
+/** toSignedBlockBoundWitnessWithStorageMeta constant. */
+export const toSignedBlockBoundWitnessWithStorageMeta = zodToFactory(
+  SignedBlockBoundWitnessWithStorageMetaishZod,
+  'toSignedBlockBoundWitnessWithStorageMeta',
+)

package/src/block/signed/index.ts

@@ -0,0 +1,3 @@
+export * from './SignedBlockBoundWitness.ts'
+export * from './SignedBlockBoundWitnessWithHashMeta.ts'
+export * from './SignedBlockBoundWitnessWithStorageMeta.ts'

package/src/block/unsigned/UnsignedBlockBoundWitness.ts

@@ -0,0 +1,22 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import { UnsignedBoundWitnessZod } from '@xyo-network/sdk-js'
+import type { z } from 'zod'
+
+import { BlockBoundWitnessFieldsZod, BlockBoundWitnessMetaZod } from '../BlockBoundWitness.ts'
+
+/** UnsignedBlockBoundWitnessZod constant. */
+export const UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod
+  .safeExtend(BlockBoundWitnessFieldsZod.shape)
+  .safeExtend(BlockBoundWitnessMetaZod.shape)
+
+/** UnsignedBlockBoundWitness type. */
+export type UnsignedBlockBoundWitness = z.infer<typeof UnsignedBlockBoundWitnessZod>
+
+/** Type guard that checks if a value is a valid UnsignedBlockBoundWitness. */
+export const isUnsignedBlockBoundWitness = zodIsFactory(UnsignedBlockBoundWitnessZod)
+/** Converts a value to UnsignedBlockBoundWitness, throwing if invalid. */
+export const asUnsignedBlockBoundWitness = zodAsFactory(UnsignedBlockBoundWitnessZod, 'asUnsignedBlockBoundWitness')
+/** toUnsignedBlockBoundWitness constant. */
+export const toUnsignedBlockBoundWitness = zodToFactory(UnsignedBlockBoundWitnessZod, 'toUnsignedBlockBoundWitness')

package/src/block/unsigned/index.ts

@@ -0,0 +1 @@
+export * from './UnsignedBlockBoundWitness.ts'

package/src/chain/Chain.ts

@@ -0,0 +1,7 @@
+import { AddressRegEx, toAddress } from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+import type { ChainId } from './ChainId.ts'
+
+/** ChainZod constant. */
+export const ChainZod = z.string().toLowerCase().regex(AddressRegEx).transform<ChainId>(v => toAddress(v) as ChainId)

package/src/chain/ChainAnalyzer.ts

@@ -0,0 +1,11 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type { Payload } from '@xyo-network/sdk-js'
+
+import type { HydratedBlock } from '../block/index.ts'
+
+/** ChainAnalyzer interface. */
+export interface ChainAnalyzer<T extends Payload = Payload> {
+  onBlock(block: HydratedBlock): Promisable<boolean>
+  result(): T
+  shouldContinue(): boolean
+}

package/src/chain/ChainId.ts

@@ -0,0 +1,4 @@
+import type { Hex } from '@xylabs/sdk-js'
+
+/** ChainId type. */
+export type ChainId = Hex

package/src/chain/index.ts

@@ -0,0 +1,3 @@
+export * from './Chain.ts'
+export * from './ChainAnalyzer.ts'
+export * from './ChainId.ts'

package/src/fields/Addressable.ts

@@ -0,0 +1,7 @@
+import type { Address } from '@xylabs/sdk-js'
+
+// NOTE: Minimal interface in case of reuse across validators, producers, wallets, modules, etc.
+/** Addressable interface. */
+export interface Addressable {
+  address: Address
+}

package/src/fields/BlockDuration.ts

@@ -0,0 +1,25 @@
+/** BlockStart interface. */
+export interface BlockStart {
+  /**
+   * The block at which the duration starts
+   */
+  nbf: number
+}
+
+/** BlockEnd interface. */
+export interface BlockEnd {
+  /**
+   * The block at which the duration ends
+   */
+  exp: number
+}
+
+/**
+ * A optional duration referenced to block numbers
+ */
+export interface OptionalBlockDuration extends Partial<BlockStart>, Partial<BlockEnd> {}
+
+/**
+ * A duration referenced to block numbers
+ */
+export interface BlockDuration extends BlockStart, BlockEnd {}