@xyo-network/xl1-rpc 1.11.0 → 1.12.1

package/src/transport/post-message/LegacyPostMessageRpcTransport.ts

@@ -8,7 +8,7 @@ import { isDefined } from '@xylabs/typeof'
 import { v4 } from 'uuid'
 import type { z } from 'zod'
 
-import type { RpcSchemaMap } from '../../types/index.ts'
+import type { RpcSchemaMap, XyoGatewayRpcMethodName } from '../../types/index.ts'
 import { jsonrpc, XyoGatewayRpcSchemas } from '../../types/index.ts'
 import type { RpcTransport } from '../RpcTransport.ts'
 import { isRpcError } from './helpers.ts'
@@ -26,23 +26,23 @@ const isRpcResponse = (data: any, targetId: string) => {
 }
 
 /** @deprecated - now part of a client gateway */
-export class LegacyPostMessageRpcTransport<T extends RpcSchemaMap = RpcSchemaMap> implements RpcTransport<T> {
+export class LegacyPostMessageRpcTransport implements RpcTransport<RpcSchemaMap<XyoGatewayRpcMethodName>> {
   protected readonly destination?: string
-  protected readonly schemas: T
+  protected readonly schemas: RpcSchemaMap<XyoGatewayRpcMethodName>
   protected readonly sessionId?: string
 
-  constructor(defaultDestination?: string, schemas: T = XyoGatewayRpcSchemas as T, sessionId?: string) {
-    this.schemas = schemas
+  constructor(defaultDestination?: string, sessionId?: string) {
+    this.schemas = XyoGatewayRpcSchemas
     this.destination = defaultDestination
     this.sessionId = sessionId
   }
 
   async sendRequest<
-    TMethod extends keyof T & string,
+    TMethod extends keyof RpcSchemaMap<XyoGatewayRpcMethodName>,
   >(
     method: TMethod,
-    params?: z.infer<T[TMethod]['params']['to']>,
-  ): Promise<z.infer<T[TMethod]['result']['from']>> {
+    params?: z.input<RpcSchemaMap<XyoGatewayRpcMethodName>[TMethod]['params']['to']>,
+  ): Promise<z.output<RpcSchemaMap<XyoGatewayRpcMethodName>[TMethod]['result']['from']>> {
     const id = v4()
     return await this.callRpc(this.schemas, method, id, params)
   }
@@ -54,15 +54,15 @@ export class LegacyPostMessageRpcTransport<T extends RpcSchemaMap = RpcSchemaMap
     schemas: TSchemas,
     method: TMethod,
     id: string,
-    params?: z.infer<TSchemas[TMethod]['params']['to']>,
-  ): Promise<z.infer<TSchemas[TMethod]['result']['from']>> {
+    params?: z.input<TSchemas[TMethod]['params']['to']>,
+  ): Promise<z.output<TSchemas[TMethod]['result']['from']>> {
     const body: JsonRpcRequest = {
       jsonrpc,
       id,
       method: method as string,
     }
 
-    body.params = (isDefined(params) && isDefined(schemas[method])) ? schemas[method].params.to.parse(params) : params
+    body.params = ((isDefined(params) && isDefined(schemas[method])) ? schemas[method].params.to.parse(params) : params) as JsonRpcRequest
 
     return await new Promise((resolve, reject) => {
       const id = body.id
@@ -92,7 +92,7 @@ export class LegacyPostMessageRpcTransport<T extends RpcSchemaMap = RpcSchemaMap
             return
           }
           if (isJsonRpcSuccess(data.eventData)) {
-            resolve(data.eventData)
+            resolve(data.eventData as z.infer<TSchemas[TMethod]['result']['from']>)
             return
           }
           reject(new Error('Unexpected response format'))

package/src/types/schema/AllRpcSchemas.ts

@@ -4,9 +4,9 @@ import { XyoRunnerRpcSchemas } from './XyoRunnerRpcSchemas.ts'
 import { XyoSignerRpcSchemas } from './XyoSignerRpcSchemas.ts'
 import { XyoViewerRpcSchemas } from './XyoViewerRpcSchemas.ts'
 
-export const AllRpcSchemas: RpcSchemaMap = {
+export const AllRpcSchemas = {
   ...XyoProviderRpcSchemas,
   ...XyoRunnerRpcSchemas,
   ...XyoSignerRpcSchemas,
   ...XyoViewerRpcSchemas,
-}
+} satisfies RpcSchemaMap

package/src/types/schema/XyoGatewayRpcSchemas.ts

@@ -1,34 +1,34 @@
-import type { Hex } from '@xylabs/hex'
+import type { Chain } from '@xyo-network/xl1-protocol'
 import { z } from 'zod'
 
 import type { XyoGatewayRpcMethodName } from '../XyoGatewayRpc.ts'
-import { BlockBoundWitnessSchema, HydratedTransactionSchema } from './common/index.ts'
+import { BlockBoundWitnessZod, HydratedTransactionZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
-export const ChainConnectionSchema = z.object({
-  chainId: z.union([z.string(), z.custom<Hex>()]).optional(),
+export const ChainConnectionZod = z.object({
+  chainId: z.union([z.string(), z.custom<Chain>()]).optional(),
   name: z.string(),
   url: z.string(),
 })
 
-export const CaveatTypesSchema = z.enum(['chain', 'expiration', 'filteredResponse', 'rateLimit'])
+export const CaveatTypesZod = z.enum(['chain', 'expiration', 'filteredResponse', 'rateLimit'])
 
-export const CaveatsSchema = z.object({
-  type: CaveatTypesSchema,
+export const CaveatsZod = z.object({
+  type: CaveatTypesZod,
   value: z.unknown(), // JsonValue is usually unknown, adjust if you have a stricter type
 })
 
-export const PermissionSchema = z.object({
+export const PermissionZod = z.object({
   capability: z.string(),
-  caveats: CaveatsSchema.array().optional(),
+  caveats: CaveatsZod.array().optional(),
   invoker: z.string(),
 })
 
-export const InvokerPermissionSchema = PermissionSchema.extend({ date: z.number().optional() })
+export const InvokerPermissionZod = PermissionZod.extend({ date: z.number().optional() })
 
-export type ChainConnection = z.infer<typeof ChainConnectionSchema>
+export type ChainConnection = z.infer<typeof ChainConnectionZod>
 
-export const XyoGatewayRpcSchemas: RpcSchemaMap<XyoGatewayRpcMethodName> = {
+export const XyoGatewayRpcSchemas = {
   /*
   xyoGateway_addConnection: {
     params: {
@@ -94,15 +94,15 @@ export const XyoGatewayRpcSchemas: RpcSchemaMap<XyoGatewayRpcMethodName> = {
   xyoGateway_submitTransaction: {
     params: {
       from: z.array(
-        HydratedTransactionSchema,
+        HydratedTransactionZod,
       ),
       to: z.array(
-        HydratedTransactionSchema,
+        HydratedTransactionZod,
       ),
     },
     result: {
-      from: BlockBoundWitnessSchema,
-      to: BlockBoundWitnessSchema,
+      from: BlockBoundWitnessZod,
+      to: BlockBoundWitnessZod,
     },
   },
-}
+} satisfies RpcSchemaMap<XyoGatewayRpcMethodName>

package/src/types/schema/XyoProviderRpcSchemas.ts

@@ -2,36 +2,36 @@ import { z } from 'zod'
 
 import type { XyoProviderRpcMethodName } from '../XyoProviderRpc.ts'
 import {
-  AddressFromStringSchema, AddressToStringSchema, PayloadSchema, SignedTransactionBoundWitnessSchema, TransactionFeesFromStingSchema,
-  TransactionFeesToStingSchema,
+  AddressZod, PayloadZod, SignedTransactionBoundWitnessZod, TransactionFeesBigIntToJsonZod,
+  TransactionFeesJsonToBigIntZod,
 } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
-export const XyoProviderRpcSchemas: RpcSchemaMap<XyoProviderRpcMethodName> = {
+export const XyoProviderRpcSchemas = {
   xyoProvider_send: {
     params: {
       to: z.tuple([
-        AddressFromStringSchema,
-        z.array(PayloadSchema),
-        z.array(PayloadSchema),
+        AddressZod,
+        z.array(PayloadZod),
+        z.array(PayloadZod),
         z.number().nonnegative(),
         z.number().nonnegative(),
-        TransactionFeesToStingSchema,
-        AddressFromStringSchema.optional(),
+        TransactionFeesBigIntToJsonZod,
+        AddressZod.optional(),
       ]),
       from: z.tuple([
-        AddressToStringSchema,
-        z.array(PayloadSchema),
-        z.array(PayloadSchema),
+        AddressZod,
+        z.array(PayloadZod),
+        z.array(PayloadZod),
         z.number().nonnegative(),
         z.number().nonnegative(),
-        TransactionFeesFromStingSchema,
-        AddressToStringSchema.optional(),
+        TransactionFeesJsonToBigIntZod,
+        AddressZod.optional(),
       ]),
     },
     result: {
-      to: SignedTransactionBoundWitnessSchema,
-      from: SignedTransactionBoundWitnessSchema,
+      to: SignedTransactionBoundWitnessZod,
+      from: SignedTransactionBoundWitnessZod,
     },
   },
-}
+} satisfies RpcSchemaMap<XyoProviderRpcMethodName>

package/src/types/schema/XyoRunnerRpcSchemas.ts

@@ -1,22 +1,19 @@
+import { HashToJsonZod, JsonToHashZod } from '@xylabs/hex'
 import { z } from 'zod'
 
 import type { XyoRunnerRpcMethodName } from '../XyoRunnerRpc.ts'
-import {
-  HashFromStringSchema,
-  HashToStringSchema,
-  SignedHydratedTransactionSchema,
-} from './common/index.ts'
+import { SignedHydratedTransactionZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
-export const XyoRunnerRpcSchemas: RpcSchemaMap<XyoRunnerRpcMethodName> = {
+export const XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z.tuple([SignedHydratedTransactionSchema]),
-      from: z.tuple([SignedHydratedTransactionSchema]),
+      to: z.tuple([SignedHydratedTransactionZod]),
+      from: z.tuple([SignedHydratedTransactionZod]),
     },
     result: {
-      to: HashToStringSchema,
-      from: HashFromStringSchema,
+      to: HashToJsonZod,
+      from: JsonToHashZod,
     },
   },
-}
+} satisfies RpcSchemaMap<XyoRunnerRpcMethodName>

package/src/types/schema/XyoSignerRpcSchemas.ts

@@ -1,60 +1,65 @@
+import type { Signed } from '@xyo-network/boundwitness-model'
+import type { SignedHydratedTransaction, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
 import { z } from 'zod'
 
 import type { XyoSignerRpcMethodName } from '../XyoSignerRpc.ts'
 import {
-  AddressFromStringSchema, AddressToStringSchema,
-  HydratedTransactionSchema,
-  PayloadSchema, SignedHydratedTransactionSchema, SignedTransactionBoundWitnessSchema,
-  TransactionFeesFromStingSchema,
-  TransactionFeesToStingSchema,
+  AddressZod,
+  AllowedBlockPayloadZod,
+  ChainZod,
+  PayloadZod, SignedHydratedTransactionZod, SignedTransactionBoundWitnessZod,
+  TransactionFeesBigIntToJsonZod,
+  TransactionFeesJsonToBigIntZod,
+  UnsignedHydratedTransactionZod,
 } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
-export const XyoSignerRpcSchemas: RpcSchemaMap<XyoSignerRpcMethodName> = {
+export const XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
       to: z.array(z.any()).length(0).optional(),
       from: z.array(z.any()).length(0).optional(),
     },
     result: {
-      to: AddressToStringSchema,
-      from: AddressFromStringSchema,
+      to: AddressZod,
+      from: AddressZod,
     },
   },
+  // NOTE: method is deprecated which is why it uses deprecated types
   xyoSigner_createSignedTransaction: {
     params: {
       to: z.tuple([
-        AddressFromStringSchema,
-        z.array(PayloadSchema),
-        z.array(PayloadSchema),
+        ChainZod,
+        z.array(AllowedBlockPayloadZod),
+        z.array(PayloadZod),
         z.number().nonnegative(),
         z.number().nonnegative(),
-        TransactionFeesToStingSchema,
-        AddressFromStringSchema.optional(),
+        TransactionFeesBigIntToJsonZod,
+        AddressZod.optional(),
       ]),
       from: z.tuple([
-        AddressToStringSchema,
-        z.array(PayloadSchema),
-        z.array(PayloadSchema),
+        ChainZod,
+        z.array(PayloadZod),
+        z.array(PayloadZod),
         z.number().nonnegative(),
         z.number().nonnegative(),
-        TransactionFeesFromStingSchema,
-        AddressToStringSchema.optional(),
+        TransactionFeesJsonToBigIntZod,
+        AddressZod.optional(),
       ]),
     },
     result: {
-      to: SignedTransactionBoundWitnessSchema,
-      from: SignedTransactionBoundWitnessSchema,
+      to: SignedTransactionBoundWitnessZod,
+      from: SignedTransactionBoundWitnessZod.transform(data => data as Signed<TransactionBoundWitness>),
     },
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z.tuple([HydratedTransactionSchema]),
-      from: z.tuple([HydratedTransactionSchema]),
+      to: z.tuple([UnsignedHydratedTransactionZod]),
+      from: z.tuple([UnsignedHydratedTransactionZod]),
     },
     result: {
-      to: SignedHydratedTransactionSchema,
-      from: SignedHydratedTransactionSchema,
+      to: SignedHydratedTransactionZod,
+      from: SignedHydratedTransactionZod.transform(data => data as SignedHydratedTransaction),
     },
   },
-}
+} as const satisfies RpcSchemaMap<XyoSignerRpcMethodName>

package/src/types/schema/XyoViewerRpcSchemas.ts

@@ -1,61 +1,64 @@
+import {
+  BigIntToJsonZod, HashToJsonZod, HashZod, JsonToBigIntZod,
+  JsonToHashZod,
+} from '@xylabs/hex'
 import { z } from 'zod'
 
 import type { XyoViewerRpcMethodName } from '../XyoViewerRpc.ts'
 import {
-  AddressFromStringSchema, AddressToStringSchema, BigIntFromStringSchema, BigIntToStringSchema,
-  BlockNumberSchema,
-  HashFromStringSchema, HashToStringSchema,
-  PayloadSchema,
-  SignedHydratedBlockSchema,
-  SignedHydratedTransactionSchema,
+  AddressZod,
+  BlockNumberZod,
+  PayloadZod,
+  SignedHydratedBlockZod,
+  SignedHydratedTransactionZod,
 } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
-export const XyoViewerRpcSchemas: RpcSchemaMap<XyoViewerRpcMethodName> = {
+export const XyoViewerRpcSchemas = {
   xyoViewer_accountBalance: {
     params: {
       to: z.union([
-        z.tuple([AddressToStringSchema]),
-        z.tuple([AddressToStringSchema, z.number()]),
-        z.tuple([AddressToStringSchema, z.number(), z.boolean()]),
+        z.tuple([AddressZod]),
+        z.tuple([AddressZod, z.number()]),
+        z.tuple([AddressZod, z.number(), z.boolean()]),
       ]),
       from: z.union([
-        z.tuple([AddressToStringSchema]),
-        z.tuple([AddressToStringSchema, z.number()]),
-        z.tuple([AddressToStringSchema, z.number(), z.boolean()]),
+        z.tuple([AddressZod]),
+        z.tuple([AddressZod, z.number()]),
+        z.tuple([AddressZod, z.number(), z.boolean()]),
       ]),
     },
     result: {
-      to: BigIntToStringSchema,
-      from: BigIntFromStringSchema,
+      to: BigIntToJsonZod,
+      from: JsonToBigIntZod,
     },
   },
   xyoViewer_accountHistory: {
     params: {
       to: z.union([
-        z.tuple([AddressToStringSchema]),
-        z.tuple([AddressToStringSchema, z.number()]),
-        z.tuple([AddressToStringSchema, z.number(), z.boolean()]),
+        z.tuple([AddressZod]),
+        z.tuple([AddressZod, z.number()]),
+        z.tuple([AddressZod, z.number(), z.boolean()]),
       ]),
       from: z.union([
-        z.tuple([AddressToStringSchema]),
-        z.tuple([AddressToStringSchema, z.number()]),
-        z.tuple([AddressToStringSchema, z.number(), z.boolean()]),
+        z.tuple([AddressZod]),
+        z.tuple([AddressZod, z.number()]),
+        z.tuple([AddressZod, z.number(), z.boolean()]),
       ]),
     },
     result: {
-      to: z.array(z.array(PayloadSchema)),
-      from: z.array(z.array(PayloadSchema)),
+      to: z.array(z.tuple([HashZod, HashZod, PayloadZod])),
+      from: z.array(z.tuple([HashZod, HashZod, PayloadZod])),
     },
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z.tuple([HashToStringSchema]),
-      from: z.tuple([HashFromStringSchema]),
+      to: z.tuple([HashToJsonZod]),
+      from: z.tuple([JsonToHashZod]),
     },
     result: {
-      to: SignedHydratedBlockSchema,
-      from: SignedHydratedBlockSchema,
+      to: SignedHydratedBlockZod,
+      from: SignedHydratedBlockZod,
     },
   },
   xyoViewer_blockByNumber: {
@@ -64,18 +67,18 @@ export const XyoViewerRpcSchemas: RpcSchemaMap<XyoViewerRpcMethodName> = {
       from: z.tuple([z.number()]),
     },
     result: {
-      to: SignedHydratedBlockSchema,
-      from: SignedHydratedBlockSchema,
+      to: SignedHydratedBlockZod,
+      from: SignedHydratedBlockZod,
     },
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z.tuple([HashToStringSchema, z.number().optional()]),
-      from: z.tuple([HashFromStringSchema, z.number().optional()]),
+      to: z.tuple([HashZod, z.number().optional()]),
+      from: z.tuple([HashZod, z.number().optional()]),
     },
     result: {
-      to: z.array(SignedHydratedBlockSchema),
-      from: z.array(SignedHydratedBlockSchema),
+      to: z.array(SignedHydratedBlockZod),
+      from: z.array(SignedHydratedBlockZod),
     },
   },
   xyoViewer_chainId: {
@@ -84,8 +87,8 @@ export const XyoViewerRpcSchemas: RpcSchemaMap<XyoViewerRpcMethodName> = {
       from: z.array(z.any()).length(0).optional(),
     },
     result: {
-      to: AddressToStringSchema,
-      from: AddressFromStringSchema,
+      to: AddressZod,
+      from: AddressZod,
     },
   },
   xyoViewer_currentBlock: {
@@ -94,8 +97,8 @@ export const XyoViewerRpcSchemas: RpcSchemaMap<XyoViewerRpcMethodName> = {
       from: z.array(z.any()).length(0).optional(),
     },
     result: {
-      to: SignedHydratedBlockSchema,
-      from: SignedHydratedBlockSchema,
+      to: SignedHydratedBlockZod,
+      from: SignedHydratedBlockZod,
     },
   },
   xyoViewer_currentBlockHash: {
@@ -104,8 +107,8 @@ export const XyoViewerRpcSchemas: RpcSchemaMap<XyoViewerRpcMethodName> = {
       from: z.array(z.any()).length(0).optional(),
     },
     result: {
-      to: HashToStringSchema,
-      from: HashFromStringSchema,
+      to: HashZod,
+      from: HashZod,
     },
   },
   xyoViewer_currentBlockNumber: {
@@ -114,18 +117,18 @@ export const XyoViewerRpcSchemas: RpcSchemaMap<XyoViewerRpcMethodName> = {
       from: z.array(z.any()).length(0).optional(),
     },
     result: {
-      to: BlockNumberSchema,
-      from: BlockNumberSchema,
+      to: BlockNumberZod,
+      from: BlockNumberZod,
     },
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z.tuple([HashToStringSchema, z.number()]),
-      from: z.tuple([HashFromStringSchema, z.number()]),
+      to: z.tuple([HashZod, z.number()]),
+      from: z.tuple([HashZod, z.number()]),
     },
     result: {
-      to: SignedHydratedTransactionSchema.nullable(),
-      from: SignedHydratedTransactionSchema.nullable(),
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable(),
     },
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
@@ -134,18 +137,18 @@ export const XyoViewerRpcSchemas: RpcSchemaMap<XyoViewerRpcMethodName> = {
       from: z.tuple([z.number(), z.number()]),
     },
     result: {
-      to: SignedHydratedTransactionSchema.nullable(),
-      from: SignedHydratedTransactionSchema.nullable(),
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable(),
     },
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z.tuple([HashToStringSchema]),
-      from: z.tuple([HashFromStringSchema]),
+      to: z.tuple([HashZod]),
+      from: z.tuple([HashZod]),
     },
     result: {
-      to: SignedHydratedTransactionSchema.nullable(),
-      from: SignedHydratedTransactionSchema.nullable(),
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable(),
     },
   },
-}
+} satisfies RpcSchemaMap<XyoViewerRpcMethodName>

package/src/types/schema/common/Address.ts

@@ -0,0 +1,5 @@
+import type { Address } from '@xylabs/hex'
+import { AddressRegEx, toAddress } from '@xylabs/hex'
+import { z } from 'zod'
+
+export const AddressZod = z.string().toLowerCase().regex(AddressRegEx).transform<Address>(v => toAddress(v))

package/src/types/schema/common/AllowedBlockPayload.ts

@@ -0,0 +1,16 @@
+import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
+import { SchemaSchema } from '@xyo-network/core-payload-plugins'
+import {
+  ChainStakeIntentSchema, HashSchema, TransferSchema,
+} from '@xyo-network/xl1-protocol'
+import z from 'zod'
+
+const AllowedBlockPayloadSchemas = [
+  BoundWitnessSchema,
+  ChainStakeIntentSchema,
+  HashSchema,
+  SchemaSchema,
+  TransferSchema,
+] as const
+
+export const AllowedBlockPayloadZod = z.object({ schema: z.enum(AllowedBlockPayloadSchemas) })

package/src/types/schema/common/BlockBoundWitness.ts

@@ -0,0 +1,49 @@
+import { HexZod } from '@xylabs/hex'
+import { z } from 'zod'
+
+import {
+  SignedBoundWitnessWithStorageMetaZod, SignedBoundWitnessZod, UnsignedBoundWitnessWithStorageMetaZod,
+  UnsignedBoundWitnessZod,
+} from './BoundWitness.ts'
+import { ChainZod } from './Chain.ts'
+import { StorageMetaZod } from './Payload.ts'
+
+export const BlockNumberZod = z.number().int().nonnegative()
+
+const BlockBoundWitnessFieldsZod = z.object({
+  block: BlockNumberZod,
+  chain: ChainZod,
+  previous: HexZod.nullable(),
+  protocol: z.number().optional(),
+  step_hashes: z.array(HexZod).optional(),
+})
+
+const BlockBoundWitnessMetaZod = z.object({ $epoch: z.number() })
+
+export const BlockBoundWitnessZod = UnsignedBoundWitnessZod
+// eslint-disable-next-line sonarjs/deprecation
+  .merge(StorageMetaZod.partial())
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(BlockBoundWitnessFieldsZod)
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(BlockBoundWitnessMetaZod)
+export const BlockBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(BlockBoundWitnessFieldsZod)
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(BlockBoundWitnessMetaZod)
+
+export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(StorageMetaZod.partial())
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(BlockBoundWitnessFieldsZod)
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(BlockBoundWitnessMetaZod)
+export const SignedBlockBoundWitnessWithStorageMetaZod = SignedBoundWitnessWithStorageMetaZod
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(StorageMetaZod.partial())
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(BlockBoundWitnessFieldsZod)
+  // eslint-disable-next-line sonarjs/deprecation
+  .merge(BlockBoundWitnessMetaZod)

package/src/types/schema/common/BoundWitness.ts

@@ -0,0 +1,53 @@
+import { HashZod, HexZod } from '@xylabs/hex'
+import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
+import { z } from 'zod'
+
+import { AddressZod } from './Address.ts'
+import { PayloadZod, SchemaZod } from './Payload.ts'
+
+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
+  .extend(BoundWitnessRequiredFieldsZod.shape)
+  .extend(BoundWitnessMetaZod.shape)
+
+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/types/schema/common/Chain.ts

@@ -0,0 +1,5 @@
+import { AddressRegEx, toAddress } from '@xylabs/hex'
+import type { Chain } from '@xyo-network/xl1-protocol'
+import { z } from 'zod'
+
+export const ChainZod = z.string().toLowerCase().regex(AddressRegEx).transform<Chain>(v => toAddress(v) as Chain)