@xyo-network/xl1-rpc 1.11.0 → 1.12.0

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/{AddressSchema.ts → Address.ts}

@@ -5,5 +5,4 @@ import { z } from 'zod'
 
 const CompiledAddressRegEx = new RegExp(AddressRegEx)
 
-export const AddressToStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx)
-export const AddressFromStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx).transform<Address>(v => toAddress(v))
+export const AddressZod = z.string().toLowerCase().regex(CompiledAddressRegEx).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,8 @@
+import { toAddress } from '@xylabs/hex'
+import { AddressRegEx } from '@xyo-network/payload-wrapper'
+import type { Chain } from '@xyo-network/xl1-protocol'
+import { z } from 'zod'
+
+const CompiledAddressRegEx = new RegExp(AddressRegEx)
+
+export const ChainZod = z.string().toLowerCase().regex(CompiledAddressRegEx).transform<Chain>(v => toAddress(v) as Chain)

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

@@ -0,0 +1,32 @@
+import { z } from 'zod'
+
+import {
+  BlockBoundWitnessWithStorageMetaZod, BlockBoundWitnessZod, SignedBlockBoundWitnessWithStorageMetaZod,
+  SignedBlockBoundWitnessZod,
+} from './BlockBoundWitness.ts'
+import { PayloadWithStorageMetaZod, PayloadZod } from './Payload.ts'
+
+export const HydratedBlockZod = z.tuple([
+  BlockBoundWitnessZod,
+  z.array(PayloadZod),
+])
+
+export const HydratedBlockWithStorageMetaZod = z.tuple([
+  BlockBoundWitnessWithStorageMetaZod,
+  z.array(PayloadWithStorageMetaZod),
+])
+
+export const SignedHydratedBlockZod = z.tuple([
+  SignedBlockBoundWitnessZod,
+  z.array(PayloadZod),
+])
+
+export const SignedHydratedBlockToJsonZod = z.tuple([
+  SignedBlockBoundWitnessZod,
+  z.array(PayloadZod),
+])
+
+export const SignedHydratedBlockWithStorageMetaZod = z.tuple([
+  SignedBlockBoundWitnessWithStorageMetaZod,
+  z.array(PayloadWithStorageMetaZod),
+])

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

@@ -0,0 +1,38 @@
+import type { JsonObject } from '@xylabs/object'
+import { asAnyPayload } from '@xyo-network/payload-model'
+import { asSignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+import { z } from 'zod'
+
+import { PayloadZod } from './Payload.ts'
+import { SignedTransactionBoundWitnessZod, TransactionBoundWitnessZod } from './TransactionBoundWitness.ts'
+
+export const HydratedTransactionZod = z.tuple([
+  TransactionBoundWitnessZod,
+  z.array(PayloadZod),
+])
+
+export const UnsignedHydratedTransactionZod = z.tuple([
+  TransactionBoundWitnessZod,
+  z.array(PayloadZod),
+])
+
+export const SignedHydratedTransactionZod = z.tuple([
+  SignedTransactionBoundWitnessZod,
+  z.array(PayloadZod),
+])
+
+export const SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([
+  tx,
+  payloads,
+]) => asSignedHydratedTransaction([
+  tx as JsonObject,
+  payloads.map(payload => payload as JsonObject),
+]))
+
+export const JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(([
+  tx,
+  payloads,
+]) => ([
+  asSignedHydratedTransaction(tx),
+  payloads.map(p => asAnyPayload(p)),
+]))