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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/xl1-protocol-model",
-  "version": "1.26.11",
+  "version": "1.26.13",
   "description": "XYO Layer One Protocol Model Types",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -22,7 +22,6 @@
   "exports": {
     ".": {
       "types": "./dist/neutral/index.d.ts",
-      "source": "./src/index.ts",
       "default": "./dist/neutral/index.mjs"
     },
     "./package.json": "./package.json"
@@ -32,21 +31,41 @@
   "types": "./dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "README.md"
   ],
   "devDependencies": {
+    "@firebase/app": "0.x",
+    "@firebase/app-compat": "0.x",
+    "@firebase/app-types": "0.x",
+    "@firebase/util": "1.x",
+    "@metamask/providers": "^22",
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.90",
-    "@xylabs/ts-scripts-common": "~7.5.6",
-    "@xylabs/ts-scripts-yarn3": "~7.5.6",
-    "@xylabs/tsconfig": "~7.5.6",
-    "@xyo-network/sdk-js": "^5.3.17",
+    "@xylabs/geo": "^5",
+    "@xylabs/sdk-js": "^5.0.91",
+    "@xylabs/ts-scripts-common": "~7.6.13",
+    "@xylabs/ts-scripts-yarn3": "~7.6.13",
+    "@xylabs/tsconfig": "~7.6.13",
+    "@xyo-network/sdk-js": "^5.3.22",
+    "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0",
+    "ajv": "^8",
+    "axios": "^1.14.0",
+    "cosmiconfig": ">=9",
+    "esbuild": ">=0.18",
+    "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0",
+    "ethers": "^6.16.0",
+    "firebase": "^12",
+    "lru-cache": "^11",
+    "mapbox-gl": "^3",
+    "rollup": "^3.29.4 || ^4",
+    "tslib": "^2.8.1",
     "typescript": "~5.9.3",
+    "vite": "^8.0.3",
     "vitest": "~4.1.2",
+    "webextension-polyfill": "^0.10.0 || ^0.11.0 || ^0.12.0",
     "zod": "~4.3.6"
   },
   "peerDependencies": {

package/src/BlockNumber/BlockNumber.ts

@@ -1,24 +0,0 @@
-import { type Brand } from '@xylabs/sdk-js'
-import { zodAsFactory, zodToFactory } from '@xylabs/sdk-js'
-import { z } from 'zod'
-
-import { NumberishZod } from './Numberish.ts'
-
-/** Branded number type representing a generic block number */
-export type BlockNumber = Brand<number, { readonly __blockNumber: true }>
-
-/** Zod schema that validates and brands a number as a BlockNumber */
-export const BlockNumberZod = z.number().transform(v => v as BlockNumber)
-/** Zod schema that coerces a Numberish value into a BlockNumber */
-export const BlockNumberishZod = NumberishZod.transform(v => v as BlockNumber)
-
-/** Input type for BlockNumberishZod, accepting number, string, or bigint */
-export type BlockNumberish = z.input<typeof BlockNumberishZod>
-
-/** Casts a number to BlockNumber, returning undefined if validation fails */
-export const asBlockNumber = zodAsFactory<BlockNumber>(BlockNumberZod, 'asBlockNumber')
-/** Coerces a Numberish value to BlockNumber, returning undefined if conversion fails */
-export const toBlockNumber = zodToFactory<BlockNumber>(BlockNumberishZod, 'toBlockNumber')
-
-/** The zero block number constant */
-export const BLOCK_NUMBER_ZERO = asBlockNumber(0)

package/src/BlockNumber/EthBlockNumber.ts

@@ -1,25 +0,0 @@
-import { type Brand } from '@xylabs/sdk-js'
-import { zodAsFactory, zodToFactory } from '@xylabs/sdk-js'
-import { z } from 'zod'
-
-import type { BlockNumber } from './BlockNumber.ts'
-import { BlockNumberishZod } from './BlockNumber.ts'
-
-/** Branded type representing a block number on the Ethereum chain */
-export type EthBlockNumber = Brand<BlockNumber, { readonly __ethBlockNumber: true }>
-
-/** Zod schema that validates and brands a number as an EthBlockNumber */
-export const EthBlockNumberZod = z.number().transform(v => v as EthBlockNumber)
-/** Zod schema that coerces a Numberish value into an EthBlockNumber */
-export const EthBlockNumberishZod = BlockNumberishZod.transform(v => v as EthBlockNumber)
-
-/** Input type for EthBlockNumberishZod, accepting number, string, or bigint */
-export type EthBlockNumberish = z.input<typeof EthBlockNumberishZod>
-
-/** Casts a number to EthBlockNumber, returning undefined if validation fails */
-export const asEthBlockNumber = zodAsFactory<EthBlockNumber>(EthBlockNumberZod, 'asEthBlockNumber')
-/** Coerces a Numberish value to EthBlockNumber, returning undefined if conversion fails */
-export const toEthBlockNumber = zodToFactory<EthBlockNumber>(EthBlockNumberishZod, 'toEthBlockNumber')
-
-/** The zero block number constant for the Ethereum chain */
-export const ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0)

package/src/BlockNumber/Numberish.ts

@@ -1,9 +0,0 @@
-import { z } from 'zod'
-
-/** Zod schema that accepts number, string, or bigint and coerces to number */
-export const NumberishZod = z.union([z.number(), z.string(), z.bigint()])
-  .transform(v => (typeof v === 'bigint' ? Number(v) : typeof v === 'string' ? Number(v) : v))
-  .pipe(z.number())
-
-/** A value that can be coerced to a number: number, string, or bigint */
-export type Numberish = z.input<typeof NumberishZod>

package/src/BlockNumber/XL1BlockNumber.ts

@@ -1,25 +0,0 @@
-import { type Brand } from '@xylabs/sdk-js'
-import { zodAsFactory, zodToFactory } from '@xylabs/sdk-js'
-import { z } from 'zod'
-
-import type { BlockNumber } from './BlockNumber.ts'
-import { BlockNumberishZod } from './BlockNumber.ts'
-
-/** Branded type representing a block number on the XL1 chain */
-export type XL1BlockNumber = Brand<BlockNumber, { readonly __xl1BlockNumber: true }>
-
-/** Zod schema that validates and brands a number as an XL1BlockNumber */
-export const XL1BlockNumberZod = z.number().transform(v => v as XL1BlockNumber)
-/** Zod schema that coerces a Numberish value into an XL1BlockNumber */
-export const XL1BlockNumberishZod = BlockNumberishZod.transform(v => v as XL1BlockNumber)
-
-/** Input type for XL1BlockNumberishZod, accepting number, string, or bigint */
-export type XL1BlockNumberish = z.input<typeof XL1BlockNumberishZod>
-
-/** Casts a number to XL1BlockNumber, returning undefined if validation fails */
-export const asXL1BlockNumber = zodAsFactory<XL1BlockNumber>(XL1BlockNumberZod, 'asXL1BlockNumber')
-/** Coerces a Numberish value to XL1BlockNumber, returning undefined if conversion fails */
-export const toXL1BlockNumber = zodToFactory<XL1BlockNumber>(XL1BlockNumberishZod, 'toXL1BlockNumber')
-
-/** The zero block number constant for the XL1 chain */
-export const XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0)

package/src/BlockNumber/index.ts

@@ -1,4 +0,0 @@
-export * from './BlockNumber.ts'
-export * from './EthBlockNumber.ts'
-export * from './Numberish.ts'
-export * from './XL1BlockNumber.ts'

package/src/RecordKeyType.ts

@@ -1,5 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/** Utility type that constrains T to valid record key types (string, number, or symbol) */
-
-/** RecordKeyType type. */
-export type RecordKeyType<T = keyof any> = T extends keyof any ? T : never

package/src/Step/StepHash.ts

@@ -1,10 +0,0 @@
-import type { Brand, Hash } from '@xylabs/sdk-js'
-
-/** A block hash paired with its step index */
-export interface StepHash {
-  block: Hash
-  step: number
-}
-
-/** Branded string representing a hash and step index separated by a pipe character */
-export type StepHashString = Brand<string, { readonly __stepHashString: true }>

package/src/Step/StepIdentity.ts

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

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

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

package/src/TransferPayload.ts

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

@@ -1,8 +0,0 @@
-/** 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

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

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

package/src/block/AllowedBlockPayload.ts

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

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

@@ -1,135 +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 { 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

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

@@ -1,22 +0,0 @@
-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')