@xyo-network/xl1-rpc 1.16.6 → 1.16.8

package/dist/node/types/schema/common/StepIdentity.d.ts

@@ -1,4 +1,7 @@
 import * as z from 'zod';
+/**
+ * @deprecated Use StepIdentityZod from \@xyo-network/xl1-protocol
+ */
 export declare const StepIdentityZod: z.ZodObject<{
     block: z.ZodNumber;
     step: z.ZodNumber;

package/dist/node/types/schema/common/StepIdentity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StepIdentity.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/StepIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,eAAe;;;iBAG1B,CAAA"}
+{"version":3,"file":"StepIdentity.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/StepIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB;;GAEG;AACH,eAAO,MAAM,eAAe;;;iBAG1B,CAAA"}

package/dist/node/types/schema/common/TransactionBoundWitness.d.ts

@@ -26,31 +26,17 @@ export declare const TransactionBoundWitnessZod: z.ZodObject<{
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
     nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
@@ -70,31 +56,17 @@ export declare const SignedTransactionBoundWitnessZod: z.ZodObject<{
         readonly __address: true;
     }>, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodString>;
+    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+        __schema: true;
+    }, string>>]>>;
     previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
     $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
-    _hash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
-    _dataHash: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>>;
+    _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    _dataHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
     nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
     exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;

package/dist/node/types/schema/common/TransactionBoundWitness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,aAAa;;iBAAoC,CAAA;AAC9D,eAAO,MAAM,WAAW;;iBAAoC,CAAA;AAC5D,eAAO,MAAM,gBAAgB;;;iBAAyD,CAAA;AACtF,eAAO,MAAM,eAAe;;iBAAuD,CAAA;AAEnF,eAAO,MAAM,sBAAsB;;;;;;;iBAA4C,CAAA;AAM/E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUd,CAAA;AAEzB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUV,CAAA"}
+{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,aAAa;;iBAAoC,CAAA;AAC9D,eAAO,MAAM,WAAW;;iBAAoC,CAAA;AAC5D,eAAO,MAAM,gBAAgB;;;iBAAyD,CAAA;AACtF,eAAO,MAAM,eAAe;;iBAAuD,CAAA;AAEnF,eAAO,MAAM,sBAAsB;;;;;;;iBAA4C,CAAA;AAM/E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUd,CAAA;AAEzB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUV,CAAA"}

package/dist/node/types/schema/common/Transfer.d.ts

@@ -22,35 +22,4 @@ export declare const TransferZod: z.ZodObject<{
         readonly __address: true;
     }>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
 }, z.z.core.$strict>;
-export declare const TransferZodWithStorageMeta: z.ZodObject<{
-    schema: z.ZodLiteral<"network.xyo.transfer">;
-    $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-    epoch: z.ZodNumber;
-    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>;
-    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.z.core.$strict>;
 //# sourceMappingURL=Transfer.d.ts.map

package/dist/node/types/schema/common/Transfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;mBAM5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;oBAA2E,CAAA;AACnG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2C,CAAA"}
+{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;mBAM5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;oBAA2E,CAAA"}

package/dist/node/types/schema/common/index.d.ts

@@ -6,7 +6,6 @@ export * from './Chain.ts';
 export * from './HydratedBlock.ts';
 export * from './HydratedTransaction.ts';
 export * from './Json.ts';
-export * from './Payload.ts';
 export * from './Permission.ts';
 export * from './RewardsRangeOptions.ts';
 export * from './Sequence.ts';

package/dist/node/types/schema/common/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,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,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,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,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.16.6",
+  "version": "1.16.8",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -60,30 +60,30 @@
     "@xylabs/axios": "~5.0.24",
     "@xylabs/hex": "~5.0.24",
     "@xylabs/typeof": "~5.0.24",
-    "@xyo-network/archivist-model": "~5.1.19",
-    "@xyo-network/boundwitness-model": "~5.1.19",
-    "@xyo-network/module-model": "~5.1.19",
-    "@xyo-network/node-model": "~5.1.19",
-    "@xyo-network/payload-builder": "~5.1.19",
-    "@xyo-network/payload-model": "~5.1.19",
-    "@xyo-network/xl1-protocol": "~1.13.5",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.6",
+    "@xyo-network/archivist-model": "~5.1.21",
+    "@xyo-network/boundwitness-model": "~5.1.21",
+    "@xyo-network/module-model": "~5.1.21",
+    "@xyo-network/node-model": "~5.1.21",
+    "@xyo-network/payload-builder": "~5.1.21",
+    "@xyo-network/payload-model": "~5.1.21",
+    "@xyo-network/xl1-protocol": "~1.13.6",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.8",
     "axios": "~1.13.2",
     "uuid": "~13.0.0",
     "zod": "~4.1.12"
   },
   "devDependencies": {
     "@metamask/utils": "~11.8.1",
-    "@types/node": "~24.10.0",
+    "@types/node": "~24.10.1",
     "@xylabs/logger": "~5.0.24",
     "@xylabs/object": "~5.0.24",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
     "@xylabs/vitest-extended": "~5.0.24",
-    "@xyo-network/account": "~5.1.19",
-    "@xyo-network/account-model": "~5.1.19",
-    "@xyo-network/chain-protocol": "~1.16.6",
-    "@xyo-network/wallet": "~5.1.19",
+    "@xyo-network/account": "~5.1.21",
+    "@xyo-network/account-model": "~5.1.21",
+    "@xyo-network/chain-protocol": "~1.16.8",
+    "@xyo-network/wallet": "~5.1.21",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.1",
     "typescript": "~5.9.3",

package/src/types/schema/XyoViewerRpcSchemas.ts

@@ -2,25 +2,23 @@ import {
   BigIntToJsonZod, HashToJsonZod, HashZod, JsonToBigIntZod,
   JsonToHashZod,
 } from '@xylabs/hex'
+import { WithHashMetaZod } from '@xyo-network/payload-model'
 import {
-  BlockNumberZod, BlockRangeZod, XL1BlockRangeZod,
+  BlockNumberZod, BlockRangeZod, StepIdentityZod, XL1BlockRangeZod,
 } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import type { XyoViewerRpcMethodName } from '../XyoViewerRpc.ts'
 import {
   AddressZod,
-  BlockBoundWitnessWithStorageMetaZod,
   BlockBoundWitnessZod,
   JsonToStakeZod,
-  PayloadZod,
   SignedHydratedBlockZod,
   SignedHydratedTransactionZod,
   StakeToJsonZod,
-  StepIdentityZod,
   TransactionBoundWitnessZod,
   TransferPairZod,
-  TransferZodWithStorageMeta,
+  TransferZod,
 } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
@@ -221,8 +219,8 @@ export const XyoViewerRpcSchemas = {
       from: z.tuple([AddressZod, z.union([XL1BlockRangeZod, HashZod]).optional()]),
     },
     result: {
-      to: z.array(z.tuple([BlockBoundWitnessZod, TransactionBoundWitnessZod.nullable(), TransferZodWithStorageMeta])),
-      from: z.array(z.tuple([BlockBoundWitnessZod, TransactionBoundWitnessZod.nullable(), TransferZodWithStorageMeta])),
+      to: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(TransferZod)])),
+      from: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(TransferZod)])),
     },
   },
   xyoViewer_transferPairBalance: {
@@ -241,8 +239,8 @@ export const XyoViewerRpcSchemas = {
       from: z.tuple([TransferPairZod]),
     },
     result: {
-      to: z.array(z.tuple([BlockBoundWitnessWithStorageMetaZod, z.union([TransactionBoundWitnessZod, z.null()]), PayloadZod])),
-      from: z.array(z.tuple([BlockBoundWitnessWithStorageMetaZod, z.union([TransactionBoundWitnessZod, z.null()]), PayloadZod])),
+      to: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(TransferZod)])),
+      from: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(TransferZod)])),
     },
   },
   xyoViewer_transferBalance: {
@@ -261,8 +259,8 @@ export const XyoViewerRpcSchemas = {
       from: z.tuple([AddressZod, BlockRangeZod.optional()]),
     },
     result: {
-      to: z.array(z.tuple([BlockBoundWitnessWithStorageMetaZod, z.union([TransactionBoundWitnessZod, z.null()]), PayloadZod])),
-      from: z.array(z.tuple([BlockBoundWitnessWithStorageMetaZod, z.union([TransactionBoundWitnessZod, z.null()]), PayloadZod])),
+      to: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(TransferZod)])),
+      from: z.array(z.tuple([WithHashMetaZod(BlockBoundWitnessZod), WithHashMetaZod(TransactionBoundWitnessZod).nullable(), WithHashMetaZod(TransferZod)])),
     },
   },
   xyoViewer_blockByHash: {

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

@@ -4,7 +4,7 @@ import { XL1BlockNumberZod } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
 import {
-  SignedBoundWitnessWithStorageMetaZod, SignedBoundWitnessZod, UnsignedBoundWitnessWithStorageMetaZod,
+  SignedBoundWitnessZod,
   UnsignedBoundWitnessZod,
 } from './BoundWitness.ts'
 import { ChainZod } from './Chain.ts'
@@ -26,11 +26,6 @@ export const BlockBoundWitnessZod = UnsignedBoundWitnessZod
   .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
@@ -39,11 +34,3 @@ export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
   .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

@@ -1,10 +1,11 @@
 import { HashZod, HexZod } from '@xylabs/hex'
 import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import { StorageMetaZod } from '@xyo-network/payload-model'
+import {
+  PayloadZod, SchemaZod, StorageMetaZod,
+} from '@xyo-network/payload-model'
 import * as z from 'zod'
 
 import { AddressZod } from './Address.ts'
-import { PayloadZod, SchemaZod } from './Payload.ts'
 
 const BoundWitnessRequiredFieldsZod = z.object({
   addresses: z.array(AddressZod),

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

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

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

@@ -1,24 +1,23 @@
 import type { JsonObject } from '@xylabs/object'
-import { asAnyPayload } from '@xyo-network/payload-model'
+import { asAnyPayload, PayloadZodLoose } from '@xyo-network/payload-model'
 import { asSignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
-import { PayloadZod } from './Payload.ts'
 import { SignedTransactionBoundWitnessZod, TransactionBoundWitnessZod } from './TransactionBoundWitness.ts'
 
 export const HydratedTransactionZod = z.tuple([
   TransactionBoundWitnessZod,
-  z.array(PayloadZod),
+  z.array(PayloadZodLoose),
 ])
 
 export const UnsignedHydratedTransactionZod = z.tuple([
   TransactionBoundWitnessZod,
-  z.array(PayloadZod),
+  z.array(PayloadZodLoose),
 ])
 
 export const SignedHydratedTransactionZod = z.tuple([
   SignedTransactionBoundWitnessZod,
-  z.array(PayloadZod),
+  z.array(PayloadZodLoose),
 ])
 
 export const SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([

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

@@ -1,5 +1,8 @@
 import * as z from 'zod'
 
+/**
+ * @deprecated Use StepIdentityZod from \@xyo-network/xl1-protocol
+ */
 export const StepIdentityZod = z.object({
   block: z.number(),
   step: z.number(),

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

@@ -1,5 +1,5 @@
 import { HexZod } from '@xylabs/hex'
-import { PayloadZodStrictOfSchema, StorageMetaZod } from '@xyo-network/payload-model'
+import { PayloadZodStrictOfSchema } from '@xyo-network/payload-model'
 import { TransferSchema } from '@xyo-network/xl1-protocol'
 import z from 'zod'
 
@@ -14,4 +14,3 @@ export const TransferFieldsZod = z.object({
 })
 
 export const TransferZod = PayloadZodStrictOfSchema(TransferSchema).extend(TransferFieldsZod.shape)
-export const TransferZodWithStorageMeta = TransferZod.extend(StorageMetaZod.shape)

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

@@ -6,7 +6,6 @@ export * from './Chain.ts'
 export * from './HydratedBlock.ts'
 export * from './HydratedTransaction.ts'
 export * from './Json.ts'
-export * from './Payload.ts'
 export * from './Permission.ts'
 export * from './RewardsRangeOptions.ts'
 export * from './Sequence.ts'

package/src/types/schema/common/spec/Payload.spec.ts

@@ -1,13 +1,12 @@
 import { asHash } from '@xylabs/hex'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { PayloadZod, WithStorageMetaZod } from '@xyo-network/payload-model'
 import type { HashPayload } from '@xyo-network/xl1-protocol'
 import { HashSchema } from '@xyo-network/xl1-protocol'
 import {
   describe, expect, it,
 } from 'vitest'
 
-import { PayloadWithStorageMetaZod, PayloadZod } from '../Payload.ts'
-
 const hashPayload: HashPayload = {
   schema: HashSchema,
   hash: asHash('e70f82c755ac75847f9d1c6b45d96099b343571d724e5383569724c85cc9d303', true),
@@ -22,7 +21,7 @@ describe('Payload', () => {
     expect(result.data).toEqual(hashPayload)
   })
   it('should parse a HashPayload with storage Meta', () => {
-    const result = PayloadWithStorageMetaZod.safeParse(hashPayloadWithMeta)
+    const result = WithStorageMetaZod(PayloadZod).safeParse(hashPayloadWithMeta)
     expect(result.success).toBe(true)
     expect(result.data).toEqual(hashPayloadWithMeta)
   })

package/dist/neutral/types/schema/common/Payload.d.ts

@@ -1,81 +0,0 @@
-import * as z from 'zod';
-export declare const SchemaZod: z.ZodString;
-export type Schema = z.infer<typeof SchemaZod>;
-export declare const PayloadZod: z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>;
-export declare const PayloadWithStorageMetaZod: z.ZodObject<{
-    schema: z.ZodString;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.core.$catchall<z.ZodAny>>;
-export declare const AnyPayloadZod: z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodJSONSchema>>;
-export declare const AnyPayloadWithStorageMetaZod: z.ZodObject<{
-    schema: z.ZodString;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.core.$catchall<z.ZodJSONSchema>>;
-export type PayloadZodType = z.infer<typeof PayloadZod>;
-export type PayloadWithStorageMetaZodType = z.infer<typeof PayloadWithStorageMetaZod>;
-export type AnyPayloadZodType = z.infer<typeof AnyPayloadZod>;
-export type AnyPayloadWithStorageMetaZodType = z.infer<typeof AnyPayloadWithStorageMetaZod>;
-export declare function WithStorageMetaZod<T extends typeof PayloadZod>(valueZod: T): z.ZodObject<{
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-    schema: z.ZodString;
-}, z.core.$strip>;
-export type WithStorageMetaZodType = z.infer<typeof WithStorageMetaZod>;
-//# sourceMappingURL=Payload.d.ts.map

package/dist/neutral/types/schema/common/Payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Payload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,SAAS,aAAa,CAAA;AACnC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,UAAU;;8BAAoD,CAAA;AAC3E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;8BAA0C,CAAA;AAEhF,eAAO,MAAM,aAAa;;qCAAgC,CAAA;AAC1D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;qCAA6C,CAAA;AAEtF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AACvD,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAErF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAC7D,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE3F,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,OAAO,UAAU,EAAE,QAAQ,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;kBAE1E;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/node/types/schema/common/Payload.d.ts

@@ -1,81 +0,0 @@
-import * as z from 'zod';
-export declare const SchemaZod: z.ZodString;
-export type Schema = z.infer<typeof SchemaZod>;
-export declare const PayloadZod: z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodAny>>;
-export declare const PayloadWithStorageMetaZod: z.ZodObject<{
-    schema: z.ZodString;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.core.$catchall<z.ZodAny>>;
-export declare const AnyPayloadZod: z.ZodObject<{
-    schema: z.ZodString;
-}, z.core.$catchall<z.ZodJSONSchema>>;
-export declare const AnyPayloadWithStorageMetaZod: z.ZodObject<{
-    schema: z.ZodString;
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-}, z.core.$catchall<z.ZodJSONSchema>>;
-export type PayloadZodType = z.infer<typeof PayloadZod>;
-export type PayloadWithStorageMetaZodType = z.infer<typeof PayloadWithStorageMetaZod>;
-export type AnyPayloadZodType = z.infer<typeof AnyPayloadZod>;
-export type AnyPayloadWithStorageMetaZodType = z.infer<typeof AnyPayloadWithStorageMetaZod>;
-export declare function WithStorageMetaZod<T extends typeof PayloadZod>(valueZod: T): z.ZodObject<{
-    _hash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _dataHash: z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
-        readonly __hash: true;
-    }>, unknown>>;
-    _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>;
-    schema: z.ZodString;
-}, z.core.$strip>;
-export type WithStorageMetaZodType = z.infer<typeof WithStorageMetaZod>;
-//# sourceMappingURL=Payload.d.ts.map

package/dist/node/types/schema/common/Payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Payload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,SAAS,aAAa,CAAA;AACnC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,UAAU;;8BAAoD,CAAA;AAC3E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;8BAA0C,CAAA;AAEhF,eAAO,MAAM,aAAa;;qCAAgC,CAAA;AAC1D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;qCAA6C,CAAA;AAEtF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AACvD,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAErF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAC7D,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE3F,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,OAAO,UAAU,EAAE,QAAQ,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;kBAE1E;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}