@xyo-network/xl1-protocol 1.13.13 → 1.14.1

package/dist/neutral/zod/TransactionFees.d.ts

@@ -0,0 +1,121 @@
+import * as z from 'zod';
+export declare const AttoZod: z.ZodBigInt;
+export declare const JsonToAttoZod: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>, z.ZodTransform<import("../xl1/AttoXL1.ts").AttoXL1, bigint>>;
+export declare const AttoToJsonZod: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
+export declare const TransactionFeesHexZod: z.ZodObject<{
+    base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+    gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+    gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+    priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+}, z.core.$strip>;
+export type TransactionFeesHex = z.infer<typeof TransactionFeesHexZod>;
+export declare const isTransactionFeesHex: (value: unknown) => value is {
+    base: import("@xylabs/sdk-js").Hex;
+    gasLimit: import("@xylabs/sdk-js").Hex;
+    gasPrice: import("@xylabs/sdk-js").Hex;
+    priority: import("@xylabs/sdk-js").Hex;
+};
+export declare const asTransactionFeesHex: {
+    (value: unknown): {
+        base: import("@xylabs/sdk-js").Hex;
+        gasLimit: import("@xylabs/sdk-js").Hex;
+        gasPrice: import("@xylabs/sdk-js").Hex;
+        priority: import("@xylabs/sdk-js").Hex;
+    } | undefined;
+    (value: unknown, assert: import("@xylabs/zod").ZodFactoryConfig): {
+        base: import("@xylabs/sdk-js").Hex;
+        gasLimit: import("@xylabs/sdk-js").Hex;
+        gasPrice: import("@xylabs/sdk-js").Hex;
+        priority: import("@xylabs/sdk-js").Hex;
+    };
+};
+export declare const toTransactionFeesHex: {
+    (value: unknown): {
+        base: import("@xylabs/sdk-js").Hex;
+        gasLimit: import("@xylabs/sdk-js").Hex;
+        gasPrice: import("@xylabs/sdk-js").Hex;
+        priority: import("@xylabs/sdk-js").Hex;
+    } | undefined;
+    (value: unknown, assert: import("@xylabs/zod").ZodFactoryConfig): {
+        base: import("@xylabs/sdk-js").Hex;
+        gasLimit: import("@xylabs/sdk-js").Hex;
+        gasPrice: import("@xylabs/sdk-js").Hex;
+        priority: import("@xylabs/sdk-js").Hex;
+    };
+};
+export declare const TransactionFeesBigIntZod: z.ZodObject<{
+    base: z.ZodBigInt;
+    gasLimit: z.ZodBigInt;
+    gasPrice: z.ZodBigInt;
+    priority: z.ZodBigInt;
+}, z.core.$strip>;
+export type TransactionFeesBigInt = z.infer<typeof TransactionFeesBigIntZod>;
+export declare const isTransactionFeesBigInt: (value: unknown) => value is {
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+};
+export declare const asTransactionFeesBigInt: {
+    (value: unknown): {
+        base: bigint;
+        gasLimit: bigint;
+        gasPrice: bigint;
+        priority: bigint;
+    } | undefined;
+    (value: unknown, assert: import("@xylabs/zod").ZodFactoryConfig): {
+        base: bigint;
+        gasLimit: bigint;
+        gasPrice: bigint;
+        priority: bigint;
+    };
+};
+export declare const toTransactionFeesBigInt: {
+    (value: unknown): {
+        base: bigint;
+        gasLimit: bigint;
+        gasPrice: bigint;
+        priority: bigint;
+    } | undefined;
+    (value: unknown, assert: import("@xylabs/zod").ZodFactoryConfig): {
+        base: bigint;
+        gasLimit: bigint;
+        gasPrice: bigint;
+        priority: bigint;
+    };
+};
+export declare const TransactionFeesJsonToBigIntZod: z.ZodPipe<z.ZodObject<{
+    base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+    gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+    gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+    priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+}, z.core.$strip>, z.ZodTransform<{
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+}, {
+    base: import("@xylabs/sdk-js").Hex;
+    gasLimit: import("@xylabs/sdk-js").Hex;
+    gasPrice: import("@xylabs/sdk-js").Hex;
+    priority: import("@xylabs/sdk-js").Hex;
+}>>;
+export declare const TransactionFeesBigIntToJsonZod: z.ZodPipe<z.ZodObject<{
+    base: z.ZodBigInt;
+    gasLimit: z.ZodBigInt;
+    gasPrice: z.ZodBigInt;
+    priority: z.ZodBigInt;
+}, z.core.$strip>, z.ZodTransform<{
+    base: import("@xylabs/sdk-js").Hex;
+    gasLimit: import("@xylabs/sdk-js").Hex;
+    gasPrice: import("@xylabs/sdk-js").Hex;
+    priority: import("@xylabs/sdk-js").Hex;
+}, {
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+}>>;
+export type TransactionFeesJsonToBigIntZodType = z.infer<typeof TransactionFeesJsonToBigIntZod>;
+export type TransactionFeesBigIntToJsonZodType = z.infer<typeof TransactionFeesBigIntToJsonZod>;
+//# sourceMappingURL=TransactionFees.d.ts.map

package/dist/neutral/zod/TransactionFees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../src/zod/TransactionFees.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,OAAO,aAAa,CAAA;AACjC,eAAO,MAAM,aAAa,uNAA+C,CAAA;AAEzE,eAAO,MAAM,aAAa,8EAAkB,CAAA;AAE5C,eAAO,MAAM,qBAAqB;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE,eAAO,MAAM,oBAAoB;;;;;CAAsC,CAAA;AACvE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;CAA8D,CAAA;AAC/F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;CAA8D,CAAA;AAE/F,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,eAAO,MAAM,uBAAuB;;;;;CAAyC,CAAA;AAC7E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;CAAoE,CAAA;AACxG,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;CAAoE,CAAA;AAExG,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}

package/dist/neutral/zod/TransferPair.d.ts

@@ -0,0 +1,3 @@
+import z from 'zod';
+export declare const TransferPairZod: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
+//# sourceMappingURL=TransferPair.d.ts.map

package/dist/neutral/zod/TransferPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransferPair.d.ts","sourceRoot":"","sources":["../../../src/zod/TransferPair.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,eAAe,wLAE1B,CAAA"}

package/dist/neutral/zod/index.d.ts

@@ -0,0 +1,15 @@
+export * from './ArrayBuffer.ts';
+export * from './BlockBoundWitness.ts';
+export * from './BoundWitness.ts';
+export * from './Chain.ts';
+export * from './HydratedBlock.ts';
+export * from './HydratedTransaction.ts';
+export * from './Permission.ts';
+export * from './RewardsRangeOptions.ts';
+export * from './Sequence.ts';
+export * from './Stake.ts';
+export * from './TimeDomain.ts';
+export * from './TransactionBoundWitness.ts';
+export * from './TransactionFees.ts';
+export * from './TransferPair.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/zod/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zod/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol",
-  "version": "1.13.13",
+  "version": "1.14.1",
   "description": "XYO Layer One Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -46,12 +46,13 @@
     "@xylabs/logger": "~5.0.39",
     "@xylabs/object": "~5.0.39",
     "@xylabs/promise": "~5.0.39",
+    "@xylabs/sdk-js": "~5.0.39",
     "@xylabs/typeof": "~5.0.39",
     "@xylabs/zod": "~5.0.39",
-    "@xyo-network/archivist-model": "~5.1.24",
-    "@xyo-network/boundwitness-model": "~5.1.24",
-    "@xyo-network/payload-model": "~5.1.24",
-    "@xyo-network/schema-payload-plugin": "~5.1.24",
+    "@xyo-network/archivist-model": "~5.2.0",
+    "@xyo-network/boundwitness-model": "~5.2.0",
+    "@xyo-network/payload-model": "~5.2.0",
+    "@xyo-network/schema-payload-plugin": "~5.2.0",
     "zod": "~4.1.12"
   },
   "devDependencies": {
@@ -61,7 +62,8 @@
     "@xylabs/eslint-config-flat": "~7.2.8",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xyo-network/account-model": "~5.1.24",
+    "@xyo-network/account-model": "~5.2.0",
+    "@xyo-network/payload-builder": "~5.2.0",
     "dependency-cruiser": "~17.3.1",
     "dotenv": "~17.2.3",
     "eslint": "~9.39.1",

package/src/block/AllowedBlockPayload.ts

@@ -14,7 +14,7 @@ import {
   isBridgeDestinationObservation, isBridgeIntent, isBridgeSourceObservation, isChainStakeIntent, isHashPayload, isTimePayload, isTransfer, StepCompleteSchema,
   TimeSchema, TransferSchema,
 } from '../payload/index.ts'
-import { isTransactionBoundWitness, type TransactionBoundWitness } from '../transaction/index.ts'
+import { isTransactionBoundWitness, type TransactionBoundWitness } from '../zod/index.ts'
 
 export type AllowedBlockPayload
   = Transfer

package/src/block/index.ts

@@ -1,3 +1 @@
 export * from './AllowedBlockPayload.ts'
-export * from './BlockBoundWitness.ts'
-export * from './HydratedBlock.ts'

package/src/chain/ChainAnalyzer.ts

@@ -1,7 +1,7 @@
 import type { Promisable } from '@xylabs/promise'
 import type { Payload } from '@xyo-network/payload-model'
 
-import type { HydratedBlock } from '../block/index.ts'
+import type { HydratedBlock } from '../zod/index.ts'
 
 export interface ChainAnalyzer<T extends Payload = Payload> {
   onBlock(block: HydratedBlock): Promisable<boolean>

package/src/constants/defaultTransactionFees.ts

@@ -1,5 +1,5 @@
-import type { TransactionFeesBigInt } from '../transaction/index.ts'
 import { AttoXL1, AttoXL1ConvertFactor } from '../xl1/index.ts'
+import type { TransactionFeesBigInt } from '../zod/index.ts'
 import { minTransactionFees } from './minTransactionFees.ts'
 
 export const defaultTransactionFees: TransactionFeesBigInt = {

package/src/constants/minTransactionFees.ts

@@ -1,5 +1,5 @@
-import type { TransactionFeesBigInt } from '../transaction/index.ts'
 import { AttoXL1, AttoXL1ConvertFactor } from '../xl1/index.ts'
+import type { TransactionFeesBigInt } from '../zod/index.ts'
 
 export const minTransactionFees: TransactionFeesBigInt = {
   base: AttoXL1(1000n * AttoXL1ConvertFactor.nano),

package/src/index.ts

@@ -9,6 +9,6 @@ export * from './network/index.ts'
 export * from './OpenTelemetryProviders.ts'
 export * from './payload/index.ts'
 export * from './repository/index.ts'
-export * from './transaction/index.ts'
 export * from './validation/index.ts'
 export * from './xl1/index.ts'
+export * from './zod/index.ts'

package/src/repository/TransactionReadRepository.ts

@@ -1,4 +1,4 @@
-import type { SignedHydratedTransaction, TransactionBoundWitness } from '../transaction/index.ts'
+import type { SignedHydratedTransaction, TransactionBoundWitness } from '../zod/index.ts'
 import type { ReadRepository } from './Repository.ts'
 
 export interface TransactionReadRepository extends ReadRepository<TransactionBoundWitness, SignedHydratedTransaction | undefined> {}

package/src/repository/TransactionRepositoryIterator.ts

@@ -1,4 +1,4 @@
-import type { SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness } from '../transaction/index.ts'
+import type { SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness } from '../zod/index.ts'
 import type { IterableRepository } from './Repository.ts'
 
 export interface TransactionRepositoryIterator extends IterableRepository<TransactionBoundWitness, SignedHydratedTransactionWithStorageMeta | undefined> {}

package/src/repository/TransactionWriteRepository.ts

@@ -1,4 +1,4 @@
-import type { SignedHydratedTransaction } from '../transaction/index.ts'
+import type { SignedHydratedTransaction } from '../zod/index.ts'
 import type { WriteRepository } from './Repository.ts'
 
 export interface TransactionWriteRepository extends WriteRepository<SignedHydratedTransaction, boolean> {}

package/src/validation/payload/InBlockPayloadValidationFunction.ts

@@ -1,7 +1,7 @@
 import type { Promisable } from '@xylabs/promise'
 import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 
-import type { HydratedBlock } from '../../block/index.ts'
+import type { HydratedBlock } from '../../zod/index.ts'
 import type { InBlockPayloadValidationError } from './error.ts'
 
 export type InBlockPayloadValidationFunction = (

package/src/validation/payload/error.ts

@@ -1,7 +1,7 @@
 import type { Hash } from '@xylabs/hex'
 import { type Payload } from '@xyo-network/payload-model'
 
-import { type HydratedBlock } from '../../block/index.ts'
+import type { HydratedBlock } from '../../zod/index.ts'
 import { isValidationError, ValidationError } from '../error.ts'
 
 export class InBlockPayloadValidationError extends ValidationError<Payload> {

package/src/validation/transaction/HydratedTransactionStateValidationFunction.ts

@@ -2,7 +2,7 @@ import type { Promisable } from '@xylabs/promise'
 import type { ReadArchivist } from '@xyo-network/archivist-model'
 
 import type { ChainId } from '../../model/index.ts'
-import type { HydratedTransactionWithStorageMeta, TransactionBoundWitness } from '../../transaction/index.ts'
+import type { HydratedTransactionWithStorageMeta, TransactionBoundWitness } from '../../zod/index.ts'
 import type { HydratedTransactionValidationError } from './error.ts'
 
 /**
@@ -13,7 +13,7 @@ import type { HydratedTransactionValidationError } from './error.ts'
  * @returns An array of errors if the transaction is invalid, or an empty array if it is valid.
  */
 export type HydratedTransactionStateValidationFunction<T extends TransactionBoundWitness = TransactionBoundWitness> = (
-  hydratedTransaction: HydratedTransactionWithStorageMeta<T>,
+  hydratedTransaction: T & HydratedTransactionWithStorageMeta,
   chainId: ChainId,
   archivist: ReadArchivist,
 ) => Promisable<HydratedTransactionValidationError[]>

package/src/validation/transaction/HydratedTransactionValidationFunction.ts

@@ -1,6 +1,6 @@
 import type { Promisable } from '@xylabs/promise'
 
-import type { HydratedTransactionWithStorageMeta, TransactionBoundWitness } from '../../transaction/index.ts'
+import type { HydratedTransactionWithStorageMeta, TransactionBoundWitness } from '../../zod/index.ts'
 import type { HydratedTransactionValidationError } from './error.ts'
 
 /**
@@ -10,6 +10,6 @@ import type { HydratedTransactionValidationError } from './error.ts'
  * @returns An array of errors if the transaction is invalid, or an empty array if it is valid.
  */
 export type HydratedTransactionValidationFunction<T extends TransactionBoundWitness = TransactionBoundWitness, TContext extends {} = {}> = (
-  hydratedTransaction: HydratedTransactionWithStorageMeta<T>,
+  hydratedTransaction: T & HydratedTransactionWithStorageMeta,
   context?: TContext,
 ) => Promisable<HydratedTransactionValidationError[]>

package/src/validation/transaction/error.ts

@@ -1,4 +1,4 @@
-import { type SignedHydratedTransaction } from '../../transaction/index.ts'
+import type { SignedHydratedTransaction } from '../../zod/index.ts'
 import { isValidationError, ValidationError } from '../error.ts'
 
 export class HydratedTransactionValidationError extends ValidationError<SignedHydratedTransaction> {}

package/src/zod/ArrayBuffer.ts

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

package/src/zod/BlockBoundWitness.ts

@@ -0,0 +1,38 @@
+import { HashZod } from '@xylabs/sdk-js'
+import * as z from 'zod'
+
+import { XL1BlockNumberZod } from '../model/index.ts'
+import {
+  BoundWitnessZod,
+  SignedBoundWitnessZod,
+  UnsignedBoundWitnessZod,
+} from './BoundWitness.ts'
+import { ChainZod } from './Chain.ts'
+
+export const BlockBoundWitnessFieldsZod = z.object({
+  block: XL1BlockNumberZod,
+  chain: ChainZod,
+  previous: HashZod.nullable(),
+  protocol: z.number(),
+  step_hashes: z.array(HashZod).optional(),
+})
+
+export const BlockBoundWitnessMetaZod = z.object({ $epoch: z.number() })
+
+export const BlockBoundWitnessZod = BoundWitnessZod
+  .extend(BlockBoundWitnessFieldsZod.shape)
+  .extend(BlockBoundWitnessMetaZod.shape)
+
+export type BlockBoundWitness = z.infer<typeof BlockBoundWitnessZod>
+
+export const UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod
+  .extend(BlockBoundWitnessFieldsZod.shape)
+  .extend(BlockBoundWitnessMetaZod.shape)
+
+export type UnsignedBlockBoundWitness = z.infer<typeof UnsignedBlockBoundWitnessZod>
+
+export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
+  .extend(BlockBoundWitnessFieldsZod.shape)
+  .extend(BlockBoundWitnessMetaZod.shape)
+
+export type SignedBlockBoundWitness = z.infer<typeof SignedBlockBoundWitnessZod>

package/src/zod/BoundWitness.ts

@@ -0,0 +1,59 @@
+import {
+  AddressZod, HashZod, HexZod,
+} from '@xylabs/sdk-js'
+import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
+import {
+  PayloadZod, SchemaZod, StorageMetaZod,
+} from '@xyo-network/payload-model'
+import * as z from 'zod'
+
+const BoundWitnessRequiredFieldsZod = z.object({
+  addresses: z.array(AddressZod),
+  payload_hashes: z.array(HashZod),
+  payload_schemas: z.array(SchemaZod),
+  previous_hashes: z.array(HashZod.nullable()),
+})
+
+const BoundWitnessMetaZod = z.object({
+  $destination: AddressZod.optional(),
+  $sourceQuery: HashZod.optional(),
+  $signatures: z.array(z.union([HexZod, z.null()])),
+})
+
+export const BoundWitnessZod = PayloadZod
+  .extend({ schema: z.literal(BoundWitnessSchema) })
+  .extend(BoundWitnessRequiredFieldsZod.shape)
+  .extend(BoundWitnessMetaZod.shape)
+  .refine(data => data.$signatures.length === data.addresses.length, { message: '$signatures length must equal addresses length' })
+
+export type BoundWitness = z.infer<typeof BoundWitnessZod>
+
+export const AnyBoundWitnessZod = BoundWitnessZod
+  .catchall(z.any())
+
+export type AnyBoundWitness = z.infer<typeof AnyBoundWitnessZod>
+
+export const UnsignedBoundWitnessZod = BoundWitnessZod.refine(data => data.$signatures.includes(null), { message: 'all $signatures must be null' })
+
+export type UnsignedBoundWitness = z.infer<typeof UnsignedBoundWitnessZod>
+
+export const AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod
+  .catchall(z.any())
+
+export type AnyUnsignedBoundWitness = z.infer<typeof AnyUnsignedBoundWitnessZod>
+
+export const UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod
+  .safeExtend(BoundWitnessRequiredFieldsZod.shape)
+  .safeExtend(BoundWitnessMetaZod.shape)
+  .safeExtend(StorageMetaZod.shape)
+
+export const SignedZod = z.object({ $signatures: z.array(HexZod) })
+export const UnsignedZod = z.object({ $signatures: z.array(z.null()) })
+
+export const SignedBoundWitnessZod = BoundWitnessZod.refine(data => !data.$signatures.includes(null), { message: 'all $signatures must not be null' })
+
+export const SignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod
+
+export const AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z.any())
+
+export const AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z.any())

package/src/zod/Chain.ts

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

package/src/zod/HydratedBlock.ts

@@ -0,0 +1,83 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/zod'
+import {
+  PayloadZodLoose, WithHashMetaZod, WithStorageMetaZod,
+} from '@xyo-network/payload-model'
+import * as z from 'zod'
+
+import {
+  BlockBoundWitnessZod,
+  SignedBlockBoundWitnessZod,
+} from './BlockBoundWitness.ts'
+
+export const HydratedBlockZod = z.tuple([
+  BlockBoundWitnessZod,
+  z.array(PayloadZodLoose),
+])
+
+export type HydratedBlock = z.infer<typeof HydratedBlockZod>
+
+export const isHydratedBlock = zodIsFactory(HydratedBlockZod)
+export const asHydratedBlock = zodAsFactory(HydratedBlockZod, 'asHydratedBlock')
+export const toHydratedBlock = zodToFactory(HydratedBlockZod, 'toHydratedBlock')
+
+export const HydratedBlockWithHashMetaZod = z.tuple([
+  WithHashMetaZod(BlockBoundWitnessZod),
+  z.array(WithHashMetaZod(PayloadZodLoose)),
+])
+
+export type HydratedBlockWithHashMeta = z.infer<typeof HydratedBlockWithHashMetaZod>
+
+export const isHydratedBlockWithHashMeta = zodIsFactory(HydratedBlockWithHashMetaZod)
+export const asHydratedBlockWithHashMeta = zodAsFactory(HydratedBlockWithHashMetaZod, 'asHydratedBlockWithHashMeta')
+export const toHydratedBlockWithHashMeta = zodToFactory(HydratedBlockWithHashMetaZod, 'toHydratedBlockWithHashMeta')
+
+export const HydratedBlockWithStorageMetaZod = z.tuple([
+  WithStorageMetaZod(BlockBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZodLoose)),
+])
+
+export type HydratedBlockWithStorageMeta = z.infer<typeof HydratedBlockWithStorageMetaZod>
+
+export const isHydratedBlockWithStorageMeta = zodIsFactory(HydratedBlockWithStorageMetaZod)
+export const asHydratedBlockWithStorageMeta = zodAsFactory(HydratedBlockWithStorageMetaZod, 'asHydratedBlockWithStorageMeta')
+export const toHydratedBlockWithStorageMeta = zodToFactory(HydratedBlockWithStorageMetaZod, 'toHydratedBlockWithStorageMeta')
+
+export const SignedHydratedBlockZod = z.tuple([
+  SignedBlockBoundWitnessZod,
+  z.array(PayloadZodLoose),
+])
+
+export type SignedHydratedBlock = z.infer<typeof SignedHydratedBlockZod>
+
+export const isSignedHydratedBlock = zodIsFactory(SignedHydratedBlockZod)
+export const asSignedHydratedBlock = zodAsFactory(SignedHydratedBlockZod, 'asSignedHydratedBlock')
+export const toSignedHydratedBlock = zodToFactory(SignedHydratedBlockZod, 'toSignedHydratedBlock')
+
+export const SignedHydratedBlockToJsonZod = z.tuple([
+  SignedBlockBoundWitnessZod,
+  z.array(PayloadZodLoose),
+])
+
+export type SignedHydratedBlockToJson = z.infer<typeof SignedHydratedBlockToJsonZod>
+
+export const isSignedHydratedBlockToJson = zodIsFactory(SignedHydratedBlockToJsonZod)
+export const asSignedHydratedBlockToJson = zodAsFactory(SignedHydratedBlockToJsonZod, 'asSignedHydratedBlockToJson')
+export const toSignedHydratedBlockToJson = zodToFactory(SignedHydratedBlockToJsonZod, 'toSignedHydratedBlockToJson')
+
+export const SignedHydratedBlockWithHashMetaZod = z.tuple([
+  WithHashMetaZod(SignedBlockBoundWitnessZod),
+  z.array(WithHashMetaZod(PayloadZodLoose)),
+])
+
+export type SignedHydratedBlockWithHashMeta = z.infer<typeof SignedHydratedBlockWithHashMetaZod>
+
+export const isSignedHydratedBlockWithHashMeta = zodIsFactory(SignedHydratedBlockWithHashMetaZod)
+export const asSignedHydratedBlockWithHashMeta = zodAsFactory(SignedHydratedBlockWithHashMetaZod, 'asSignedHydratedBlockWithHashMeta')
+export const toSignedHydratedBlockWithHashMeta = zodToFactory(SignedHydratedBlockWithHashMetaZod, 'toSignedHydratedBlockWithHashMeta')
+
+export const SignedHydratedBlockWithStorageMetaZod = z.tuple([
+  WithStorageMetaZod(SignedBlockBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZodLoose)),
+])