@xyo-network/xl1-protocol 1.14.13 → 1.14.15

package/dist/neutral/zod/block/signed/SignedBlockBoundWitnessWithHashMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignedBlockBoundWitnessWithHashMeta.d.ts","sourceRoot":"","sources":["../../../../../src/zod/block/signed/SignedBlockBoundWitnessWithHashMeta.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAI7B,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;iBAA2D,CAAA;AAE9G,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAA;AAExG,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;CAAuD,CAAA;AACzG,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgG,CAAA;AAElJ,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQpD,CAAA;AAEF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAA;AAE9G,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgG,CAAA"}

package/dist/neutral/zod/block/signed/SignedBlockBoundWitnessWithStorageMeta.d.ts

@@ -0,0 +1,216 @@
+import type * as z from 'zod';
+export declare const SignedBlockBoundWitnessWithStorageMetaZod: z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
+    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    payload_schemas: z.ZodArray<z.ZodString>;
+    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/hex").Address, string>>>;
+    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    $signatures: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
+    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../index.ts").XL1BlockNumber, number>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    protocol: z.ZodOptional<z.ZodNumber>;
+    step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
+    $epoch: z.ZodNumber;
+    _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;
+    _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;
+    _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.$strip>;
+export type SignedBlockBoundWitnessWithStorageMeta = z.infer<typeof SignedBlockBoundWitnessWithStorageMetaZod>;
+export declare const isSignedBlockBoundWitnessWithStorageMeta: <T>(value: T) => value is T & {
+    schema: "network.xyo.boundwitness";
+    addresses: import("@xylabs/hex").Address[];
+    payload_hashes: import("@xylabs/hex").Hash[];
+    payload_schemas: string[];
+    previous_hashes: (import("@xylabs/hex").Hash | null)[];
+    $signatures: import("@xylabs/hex").Hex[];
+    block: import("../../../index.ts").XL1BlockNumber;
+    chain: import("@xylabs/hex").Hex;
+    previous: import("@xylabs/hex").Hash | null;
+    $epoch: number;
+    _hash: import("@xylabs/hex").Hash;
+    _dataHash: import("@xylabs/hex").Hash;
+    _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+    $destination?: import("@xylabs/hex").Address | undefined;
+    $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+    protocol?: number | undefined;
+    step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+};
+export declare const asSignedBlockBoundWitnessWithStorageMeta: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: import("@xylabs/hex").Hex[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        _hash: import("@xylabs/hex").Hash;
+        _dataHash: import("@xylabs/hex").Hash;
+        _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/zod").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: import("@xylabs/hex").Hex[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        _hash: import("@xylabs/hex").Hash;
+        _dataHash: import("@xylabs/hex").Hash;
+        _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    };
+};
+export declare const SignedBlockBoundWitnessWithStorageMetaishZod: z.ZodPipe<z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
+    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    payload_schemas: z.ZodArray<z.ZodString>;
+    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/hex").Address, string>>>;
+    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    $signatures: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
+    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../index.ts").XL1BlockNumber, number>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    protocol: z.ZodOptional<z.ZodNumber>;
+    step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
+    $epoch: z.ZodNumber;
+}, z.core.$strip>, z.ZodTransform<{
+    schema: "network.xyo.boundwitness";
+    addresses: import("@xylabs/hex").Address[];
+    payload_hashes: import("@xylabs/hex").Hash[];
+    payload_schemas: string[];
+    previous_hashes: (import("@xylabs/hex").Hash | null)[];
+    $signatures: import("@xylabs/hex").Hex[];
+    block: import("../../../index.ts").XL1BlockNumber;
+    chain: import("@xylabs/hex").Hex;
+    previous: import("@xylabs/hex").Hash | null;
+    $epoch: number;
+    $destination?: import("@xylabs/hex").Address | undefined;
+    $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+    protocol?: number | undefined;
+    step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+} & {
+    schema: "network.xyo.boundwitness";
+    addresses: import("@xylabs/hex").Address[];
+    payload_hashes: import("@xylabs/hex").Hash[];
+    payload_schemas: string[];
+    previous_hashes: (import("@xylabs/hex").Hash | null)[];
+    $signatures: import("@xylabs/hex").Hex[];
+    block: import("../../../index.ts").XL1BlockNumber;
+    chain: import("@xylabs/hex").Hex;
+    previous: import("@xylabs/hex").Hash | null;
+    $epoch: number;
+    _hash: import("@xylabs/hex").Hash;
+    _dataHash: import("@xylabs/hex").Hash;
+    _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+    $destination?: import("@xylabs/hex").Address | undefined;
+    $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+    protocol?: number | undefined;
+    step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+}, {
+    schema: "network.xyo.boundwitness";
+    addresses: import("@xylabs/hex").Address[];
+    payload_hashes: import("@xylabs/hex").Hash[];
+    payload_schemas: string[];
+    previous_hashes: (import("@xylabs/hex").Hash | null)[];
+    $signatures: import("@xylabs/hex").Hex[];
+    block: import("../../../index.ts").XL1BlockNumber;
+    chain: import("@xylabs/hex").Hex;
+    previous: import("@xylabs/hex").Hash | null;
+    $epoch: number;
+    $destination?: import("@xylabs/hex").Address | undefined;
+    $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+    protocol?: number | undefined;
+    step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+}>>;
+export type SignedBlockBoundWitnessWithStorageMetaish = z.input<typeof SignedBlockBoundWitnessWithStorageMetaishZod>;
+export declare const toSignedBlockBoundWitnessWithStorageMeta: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: import("@xylabs/hex").Hex[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    } & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: import("@xylabs/hex").Hex[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        _hash: import("@xylabs/hex").Hash;
+        _dataHash: import("@xylabs/hex").Hash;
+        _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/zod").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: import("@xylabs/hex").Hex[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    } & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: import("@xylabs/hex").Hex[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        _hash: import("@xylabs/hex").Hash;
+        _dataHash: import("@xylabs/hex").Hash;
+        _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    };
+};
+//# sourceMappingURL=SignedBlockBoundWitnessWithStorageMeta.d.ts.map

package/dist/neutral/zod/block/signed/SignedBlockBoundWitnessWithStorageMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignedBlockBoundWitnessWithStorageMeta.d.ts","sourceRoot":"","sources":["../../../../../src/zod/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAI7B,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;iBAA8D,CAAA;AAEpH,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAA;AAE9G,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;CAA0D,CAAA;AAC/G,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpD,CAAA;AAED,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQvD,CAAA;AAEF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4CAA4C,CAAC,CAAA;AAEpH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpD,CAAA"}

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

@@ -0,0 +1,4 @@
+export * from './SignedBlockBoundWitness.ts';
+export * from './SignedBlockBoundWitnessWithHashMeta.ts';
+export * from './SignedBlockBoundWitnessWithStorageMeta.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/zod/block/signed/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,0CAA0C,CAAA;AACxD,cAAc,6CAA6C,CAAA"}

package/dist/neutral/zod/block/unsigned/UnsignedBlockBoundWitness.d.ts

@@ -0,0 +1,103 @@
+import type * as z from 'zod';
+export declare const UnsignedBlockBoundWitnessZod: z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
+    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    payload_schemas: z.ZodArray<z.ZodString>;
+    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/hex").Address, string>>>;
+    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    $signatures: z.ZodArray<z.ZodNull>;
+    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../index.ts").XL1BlockNumber, number>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+    protocol: z.ZodOptional<z.ZodNumber>;
+    step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
+    $epoch: z.ZodNumber;
+}, z.core.$strip>;
+export type UnsignedBlockBoundWitness = z.infer<typeof UnsignedBlockBoundWitnessZod>;
+export declare const isUnsignedBlockBoundWitness: <T>(value: T) => value is T & {
+    schema: "network.xyo.boundwitness";
+    addresses: import("@xylabs/hex").Address[];
+    payload_hashes: import("@xylabs/hex").Hash[];
+    payload_schemas: string[];
+    previous_hashes: (import("@xylabs/hex").Hash | null)[];
+    $signatures: null[];
+    block: import("../../../index.ts").XL1BlockNumber;
+    chain: import("@xylabs/hex").Hex;
+    previous: import("@xylabs/hex").Hash | null;
+    $epoch: number;
+    $destination?: import("@xylabs/hex").Address | undefined;
+    $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+    protocol?: number | undefined;
+    step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+};
+export declare const asUnsignedBlockBoundWitness: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: null[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/zod").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: null[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    };
+};
+export declare const toUnsignedBlockBoundWitness: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: null[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/zod").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness";
+        addresses: import("@xylabs/hex").Address[];
+        payload_hashes: import("@xylabs/hex").Hash[];
+        payload_schemas: string[];
+        previous_hashes: (import("@xylabs/hex").Hash | null)[];
+        $signatures: null[];
+        block: import("../../../index.ts").XL1BlockNumber;
+        chain: import("@xylabs/hex").Hex;
+        previous: import("@xylabs/hex").Hash | null;
+        $epoch: number;
+        $destination?: import("@xylabs/hex").Address | undefined;
+        $sourceQuery?: import("@xylabs/hex").Hash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@xylabs/hex").Hash[] | undefined;
+    };
+};
+//# sourceMappingURL=UnsignedBlockBoundWitness.d.ts.map

package/dist/neutral/zod/block/unsigned/UnsignedBlockBoundWitness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnsignedBlockBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/zod/block/unsigned/UnsignedBlockBoundWitness.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAI7B,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;iBAEI,CAAA;AAE7C,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;CAA6C,CAAA;AACrF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4E,CAAA;AACpH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4E,CAAA"}

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

@@ -0,0 +1,2 @@
+export * from './UnsignedBlockBoundWitness.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/zod/block/unsigned/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA"}

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

@@ -1,8 +1,9 @@
 export * from './ArrayBuffer.ts';
-export * from './BlockBoundWitness.ts';
+export * from './block/index.ts';
 export * from './Chain.ts';
 export * from './HydratedBlock.ts';
 export * from './HydratedTransaction.ts';
+export * from './payload/index.ts';
 export * from './Permission.ts';
 export * from './RewardsRangeOptions.ts';
 export * from './Sequence.ts';

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

@@ -1 +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,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zod/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,oBAAoB,CAAA;AAClC,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/dist/neutral/zod/payload/WithHashMetaish.d.ts

@@ -0,0 +1,27 @@
+import type z from 'zod';
+export declare const WithHashMetaishZod: z.ZodPipe<z.ZodObject<{
+    schema: z.ZodString;
+}, z.z.core.$strict>, z.ZodTransform<import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
+    schema: string;
+} & Partial<import("@xyo-network/payload-model").PayloadMetaFields> & {
+    _hash: import("@xylabs/hex").Hash;
+    _dataHash: import("@xylabs/hex").Hash;
+}, {
+    schema: string;
+}>>;
+export type WithHashMetaish = z.input<typeof WithHashMetaishZod>;
+export declare const toWithHashMeta: {
+    <T>(value: T): Promise<(T & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
+        schema: string;
+    } & Partial<import("@xyo-network/payload-model").PayloadMetaFields> & {
+        _hash: import("@xylabs/hex").Hash;
+        _dataHash: import("@xylabs/hex").Hash;
+    }) | undefined>;
+    <T>(value: T, assert: import("@xylabs/zod").ZodFactoryConfig): Promise<T & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
+        schema: string;
+    } & Partial<import("@xyo-network/payload-model").PayloadMetaFields> & {
+        _hash: import("@xylabs/hex").Hash;
+        _dataHash: import("@xylabs/hex").Hash;
+    }>;
+};
+//# sourceMappingURL=WithHashMetaish.d.ts.map

package/dist/neutral/zod/payload/WithHashMetaish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithHashMetaish.d.ts","sourceRoot":"","sources":["../../../../src/zod/payload/WithHashMetaish.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;GAQ7B,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAG1B,CAAA"}

package/dist/neutral/zod/payload/WithStorageMetaish.d.ts

@@ -0,0 +1,30 @@
+import type z from 'zod';
+export declare const WithStorageMetaishZod: z.ZodPipe<z.ZodObject<{
+    schema: z.ZodString;
+}, z.z.core.$strict>, z.ZodTransform<import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
+    schema: string;
+} & Partial<import("@xyo-network/payload-model").PayloadMetaFields> & {
+    _hash: import("@xylabs/hex").Hash;
+    _dataHash: import("@xylabs/hex").Hash;
+    _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+}, {
+    schema: string;
+}>>;
+export type WithStorageMetaish = z.input<typeof WithStorageMetaishZod>;
+export declare const toWithStorageMeta: {
+    <T>(value: T): Promise<(T & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
+        schema: string;
+    } & Partial<import("@xyo-network/payload-model").PayloadMetaFields> & {
+        _hash: import("@xylabs/hex").Hash;
+        _dataHash: import("@xylabs/hex").Hash;
+        _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+    }) | undefined>;
+    <T>(value: T, assert: import("@xylabs/zod").ZodFactoryConfig): Promise<T & import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
+        schema: string;
+    } & Partial<import("@xyo-network/payload-model").PayloadMetaFields> & {
+        _hash: import("@xylabs/hex").Hash;
+        _dataHash: import("@xylabs/hex").Hash;
+        _sequence: import("@xyo-network/payload-model").LocalSequence | import("@xyo-network/payload-model").QualifiedSequence;
+    }>;
+};
+//# sourceMappingURL=WithStorageMetaish.d.ts.map

package/dist/neutral/zod/payload/WithStorageMetaish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithStorageMetaish.d.ts","sourceRoot":"","sources":["../../../../src/zod/payload/WithStorageMetaish.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,qBAAqB;;;;;;;;;;GAQhC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CAG7B,CAAA"}

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

@@ -0,0 +1,3 @@
+export * from './WithHashMetaish.ts';
+export * from './WithStorageMetaish.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/zod/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,yBAAyB,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol",
-  "version": "1.14.13",
+  "version": "1.14.15",
   "description": "XYO Layer One Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -40,39 +40,40 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "~1.9.0",
-    "@xylabs/assert": "~5.0.41",
-    "@xylabs/error": "~5.0.41",
-    "@xylabs/hex": "~5.0.41",
-    "@xylabs/logger": "~5.0.41",
-    "@xylabs/object": "~5.0.41",
-    "@xylabs/promise": "~5.0.41",
-    "@xylabs/sdk-js": "~5.0.41",
-    "@xylabs/typeof": "~5.0.41",
-    "@xylabs/zod": "~5.0.41",
-    "@xyo-network/archivist-model": "~5.2.6",
-    "@xyo-network/boundwitness-model": "~5.2.6",
-    "@xyo-network/payload-model": "~5.2.6",
-    "@xyo-network/schema-payload-plugin": "~5.2.6",
-    "zod": "~4.1.12"
+    "@xylabs/assert": "~5.0.46",
+    "@xylabs/error": "~5.0.46",
+    "@xylabs/hex": "~5.0.46",
+    "@xylabs/logger": "~5.0.46",
+    "@xylabs/object": "~5.0.46",
+    "@xylabs/promise": "~5.0.46",
+    "@xylabs/sdk-js": "~5.0.46",
+    "@xylabs/typeof": "~5.0.46",
+    "@xylabs/zod": "~5.0.46",
+    "@xyo-network/archivist-model": "~5.2.10",
+    "@xyo-network/boundwitness-model": "~5.2.10",
+    "@xyo-network/payload-builder": "~5.2.10",
+    "@xyo-network/payload-model": "~5.2.10",
+    "@xyo-network/schema-payload-plugin": "~5.2.10",
+    "zod": "~4.1.13"
   },
   "devDependencies": {
     "@types/node": "~24.10.1",
-    "@typescript-eslint/types": "~8.47.0",
-    "@xylabs/creatable": "~5.0.41",
+    "@typescript-eslint/types": "~8.48.0",
+    "@xylabs/creatable": "~5.0.46",
     "@xylabs/eslint-config-flat": "~7.2.8",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xyo-network/account-model": "~5.2.6",
-    "@xyo-network/payload-builder": "~5.2.6",
+    "@xyo-network/account-model": "~5.2.10",
+    "@xyo-network/payload-builder": "~5.2.10",
     "dependency-cruiser": "~17.3.1",
     "dotenv": "~17.2.3",
     "eslint": "~9.39.1",
     "eslint-import-resolver-typescript": "~4.4.4",
-    "knip": "~5.70.1",
+    "knip": "~5.70.2",
     "typescript": "~5.9.3",
     "vite": "~7.2.4",
     "vite-tsconfig-paths": "~5.1.4",
-    "vitest": "~4.0.12"
+    "vitest": "~4.0.13"
   },
   "packageManager": "yarn@4.10.3",
   "engines": {

package/src/payload/elevatable/Time.ts

@@ -1,10 +1,8 @@
 import { HashZod } from '@xylabs/hex'
 import { AsObjectFactory } from '@xylabs/object'
-import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
+import { isPayloadOfSchemaType, PayloadZodOfSchema } from '@xyo-network/payload-model'
 import z from 'zod'
 
-import { PayloadZodOfSchema } from './TransferPayload.ts'
-
 // xl1 = xl1 block number, epoch = epoch number, ethereum = ethereum block number
 export type TimeDomain = 'xl1' | 'epoch' | 'ethereum'
 

package/src/payload/elevatable/TransferPayload.ts

@@ -3,7 +3,7 @@ import {
   HexZod,
 } from '@xylabs/hex'
 import { AsObjectFactory, JsonObjectZod } from '@xylabs/object'
-import { isPayloadOfSchemaType, PayloadZod } from '@xyo-network/payload-model'
+import { isPayloadOfSchemaType, PayloadZodOfSchema } from '@xyo-network/payload-model'
 import z from 'zod'
 
 export const TransferSchema = 'network.xyo.transfer' as const
@@ -17,8 +17,6 @@ export const TransferFieldsZod = z.object({
   transfers: z.record(AddressZod, HexZod),
 })
 
-export const PayloadZodOfSchema = <S extends string>(schema: S) => PayloadZod.extend({ schema: z.literal(schema) })
-
 export const TransferZod = PayloadZodOfSchema(TransferSchema).extend(TransferFieldsZod.shape)
 
 export type Transfer = z.infer<typeof TransferZod>

package/src/zod/HydratedBlock.ts

@@ -9,7 +9,7 @@ import * as z from 'zod'
 import {
   BlockBoundWitnessZod,
   SignedBlockBoundWitnessZod,
-} from './BlockBoundWitness.ts'
+} from './block/index.ts'
 
 export const HydratedBlockZod = z.tuple([
   BlockBoundWitnessZod,
@@ -73,11 +73,27 @@ export const SignedHydratedBlockWithHashMetaZod = z.tuple([
 
 export type SignedHydratedBlockWithHashMeta = z.infer<typeof SignedHydratedBlockWithHashMetaZod>
 
+export const SignedHydratedBlockWithHashMetaishZod = z.tuple([
+  z.union([WithHashMetaZod(SignedBlockBoundWitnessZod)]),
+  z.array(WithHashMetaZod(PayloadZodLoose)),
+])
+
 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)),
 ])
+export type SignedHydratedBlockWithStorageMeta = z.infer<typeof SignedHydratedBlockWithStorageMetaZod>
+
+export const isSignedHydratedBlockWithStorageMeta = zodIsFactory(SignedHydratedBlockWithStorageMetaZod)
+export const asSignedHydratedBlockWithStorageMeta = zodAsFactory(SignedHydratedBlockWithStorageMetaZod, 'asSignedHydratedBlockWithStorageMeta')
+export const toSignedHydratedBlockWithStorageMeta = zodToFactory(SignedHydratedBlockWithStorageMetaZod, 'toSignedHydratedBlockWithStorageMeta')
+
+export const SignedHydratedBlockWithStorageMetaishZod = z.tuple([
+  z.union([WithStorageMetaZod(SignedBlockBoundWitnessZod)]),
+  z.array(WithStorageMetaZod(PayloadZodLoose)),
+])

package/src/zod/block/BlockBoundWitness.ts

@@ -0,0 +1,48 @@
+import { HashZod } from '@xylabs/sdk-js'
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/zod'
+import { BoundWitnessZod } from '@xyo-network/boundwitness-model'
+import { HashMetaZod, StorageMetaZod } from '@xyo-network/payload-model'
+import * as z from 'zod'
+
+import { XL1BlockNumberZod } from '../../model/index.ts'
+import { ChainZod } from '../Chain.ts'
+
+export const BlockBoundWitnessFieldsZod = z.object({
+  block: XL1BlockNumberZod,
+  chain: ChainZod,
+  previous: HashZod.nullable(),
+  protocol: z.number().optional(),
+  step_hashes: z.array(HashZod).optional(),
+})
+
+export const BlockBoundWitnessMetaZod = z.object({ $epoch: z.number() })
+
+export const BlockBoundWitnessZod = BoundWitnessZod
+  .safeExtend(BlockBoundWitnessFieldsZod.shape)
+  .safeExtend(BlockBoundWitnessMetaZod.shape)
+
+export type BlockBoundWitness = z.infer<typeof BlockBoundWitnessZod>
+
+export const isBlockBoundWitness = zodIsFactory(BlockBoundWitnessZod)
+export const asBlockBoundWitness = zodAsFactory(BlockBoundWitnessZod, 'asBlockBoundWitness')
+export const toBlockBoundWitness = zodToFactory(BlockBoundWitnessZod, 'toBlockBoundWitness')
+
+export const BlockBoundWitnessWithHashMetaZod = BlockBoundWitnessZod
+  .safeExtend(HashMetaZod.shape)
+
+export type BlockBoundWitnessWithHashMeta = z.infer<typeof BlockBoundWitnessWithHashMetaZod>
+
+export const isBlockBoundWitnessWithHashMeta = zodIsFactory(BlockBoundWitnessWithHashMetaZod)
+export const asBlockBoundWitnessWithHashMeta = zodAsFactory(BlockBoundWitnessWithHashMetaZod, 'asBlockBoundWitnessWithHashMeta')
+export const toBlockBoundWitnessWithHashMeta = zodToFactory(BlockBoundWitnessWithHashMetaZod, 'toBlockBoundWitnessWithHashMeta')
+
+export const BlockBoundWitnessWithStorageMetaZod = BlockBoundWitnessZod
+  .safeExtend(StorageMetaZod.shape)
+
+export type BlockBoundWitnessWithStorageMeta = z.infer<typeof BlockBoundWitnessWithStorageMetaZod>
+
+export const isBlockBoundWitnessWithStorageMeta = zodIsFactory(BlockBoundWitnessWithStorageMetaZod)
+export const asBlockBoundWitnessWithStorageMeta = zodAsFactory(BlockBoundWitnessWithStorageMetaZod, 'asBlockBoundWitnessWithStorageMeta')
+export const toBlockBoundWitnessWithStorageMeta = zodToFactory(BlockBoundWitnessWithStorageMetaZod, 'toBlockBoundWitnessWithStorageMeta')