@xyo-network/xl1-protocol 5.4.2 → 5.5.1

package/dist/neutral/modules/protocol-model/payload/slash/SlashEvidencePayload.d.ts

@@ -1,4 +1,3 @@
-import type { Payload } from '@xyo-network/sdk';
 import { z } from 'zod/mini';
 /** Schema identifier for slash evidence payloads. */
 export declare const SlashEvidenceSchema: "network.xyo.chain.slash.evidence" & {
@@ -25,9 +24,85 @@ export declare const SlashEvidenceFieldsZod: z.ZodMiniObject<{
 /** Fields represented by the slash evidence contract. */
 export type SlashEvidenceFields = z.infer<typeof SlashEvidenceFieldsZod>;
 /** A slash evidence payload — signed artifacts carried on-chain without being interpreted. */
-export type SlashEvidence = Payload<SlashEvidenceFields, SlashEvidenceSchema>;
+export declare const SlashEvidenceZod: z.ZodMiniObject<{
+    $version: z.ZodMiniOptional<z.ZodMiniNumberFormat<z.core.$ZodNumberFormats>>;
+    schema: z.ZodMiniLiteral<"network.xyo.chain.slash.evidence" & {
+        readonly __schema: true;
+    }>;
+    artifacts: z.ZodMiniArray<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
+    from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+}, z.core.$strip>;
+/** A slash evidence payload — signed artifacts carried on-chain without being interpreted. */
+export type SlashEvidence = z.infer<typeof SlashEvidenceZod>;
 /** Type guard that checks if a value is a valid SlashEvidence. */
-export declare const isSlashEvidence: (x?: unknown) => x is SlashEvidence;
+export declare const isSlashEvidence: <T>(value: T) => value is T & {
+    schema: "network.xyo.chain.slash.evidence" & {
+        readonly __schema: true;
+    };
+    artifacts: Record<string, unknown>[];
+    from: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("@xyo-network/sdk").XyoQuantAddress;
+    $version?: number | undefined;
+};
 /** Casts a value to SlashEvidence or returns undefined if invalid. */
-export declare const asSlashEvidence: import("@ariestools/sdk").AsTypeFunction<SlashEvidence>;
+export declare const asSlashEvidence: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.chain.slash.evidence" & {
+            readonly __schema: true;
+        };
+        artifacts: Record<string, unknown>[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.chain.slash.evidence" & {
+            readonly __schema: true;
+        };
+        artifacts: Record<string, unknown>[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $version?: number | undefined;
+    };
+};
+/** Coerces a value to SlashEvidence or returns undefined if invalid. */
+export declare const toSlashEvidence: {
+    (value: unknown): {
+        schema: "network.xyo.chain.slash.evidence" & {
+            readonly __schema: true;
+        };
+        artifacts: Record<string, unknown>[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $version?: number | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        schema: "network.xyo.chain.slash.evidence" & {
+            readonly __schema: true;
+        };
+        artifacts: Record<string, unknown>[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $version?: number | undefined;
+    };
+};
 //# sourceMappingURL=SlashEvidencePayload.d.ts.map

package/dist/neutral/modules/protocol-model/payload/slash/SlashEvidencePayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SlashEvidencePayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashEvidencePayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,qDAAqD;AACrD,eAAO,MAAM,mBAAmB;;CAAqD,CAAA;AACrF,+CAA+C;AAC/C,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA;AAE5D;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;;iBAKjC,CAAA;AAEF,yDAAyD;AACzD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE,8FAA8F;AAC9F,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,mBAAmB,EAAE,mBAAmB,CAAC,CAAA;AAE7E,kEAAkE;AAClE,eAAO,MAAM,eAAe,qCAAiF,CAAA;AAE7G,sEAAsE;AACtE,eAAO,MAAM,eAAe,yDAA0C,CAAA"}
+{"version":3,"file":"SlashEvidencePayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashEvidencePayload.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,qDAAqD;AACrD,eAAO,MAAM,mBAAmB;;CAAqD,CAAA;AACrF,+CAA+C;AAC/C,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA;AAE5D;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;;iBAKjC,CAAA;AAEF,yDAAyD;AACzD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE,8FAA8F;AAC9F,eAAO,MAAM,gBAAgB;;;;;;;;;;;iBAAkF,CAAA;AAE/G,8FAA8F;AAC9F,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE5D,kEAAkE;AAClE,eAAO,MAAM,eAAe;;;;;;;;;;;CAAiC,CAAA;AAC7D,sEAAsE;AACtE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA;AAChF,wEAAwE;AACxE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA"}

package/dist/neutral/modules/protocol-model/payload/slash/SlashRequestPayload.d.ts

@@ -1,4 +1,3 @@
-import type { Payload } from '@xyo-network/sdk';
 import { z } from 'zod/mini';
 /** Schema identifier for slash request payloads. */
 export declare const SlashRequestSchema: "network.xyo.chain.slash.request" & {
@@ -38,9 +37,145 @@ export declare const SlashRequestFieldsZod: z.ZodMiniObject<{
 /** Fields represented by the slash request contract. */
 export type SlashRequestFields = z.infer<typeof SlashRequestFieldsZod>;
 /** A slash request payload — an evidence-bearing accusation. */
-export type SlashRequest = Payload<SlashRequestFields, SlashRequestSchema>;
+export declare const SlashRequestZod: z.ZodMiniObject<{
+    $version: z.ZodMiniOptional<z.ZodMiniNumberFormat<z.core.$ZodNumberFormats>>;
+    schema: z.ZodMiniLiteral<"network.xyo.chain.slash.request" & {
+        readonly __schema: true;
+    }>;
+    accused: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+    catalog: z.ZodMiniNumber<number>;
+    chain: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    evidence: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    evm: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    offense: z.ZodMiniLiteral<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation">;
+}, z.core.$strip>;
+/** A slash request payload — an evidence-bearing accusation. */
+export type SlashRequest = z.infer<typeof SlashRequestZod>;
 /** Type guard that checks if a value is a valid SlashRequest. */
-export declare const isSlashRequest: (x?: unknown) => x is SlashRequest;
+export declare const isSlashRequest: <T>(value: T) => value is T & {
+    schema: "network.xyo.chain.slash.request" & {
+        readonly __schema: true;
+    };
+    accused: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("@xyo-network/sdk").XyoQuantAddress;
+    block: import('../../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+    catalog: number;
+    chain: import("@ariestools/sdk").BrandedHex;
+    evidence: import("@ariestools/sdk").BrandedHash[];
+    from: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("@xyo-network/sdk").XyoQuantAddress;
+    offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+    $version?: number | undefined;
+    evm?: number | undefined;
+};
 /** Casts a value to SlashRequest or returns undefined if invalid. */
-export declare const asSlashRequest: import("@ariestools/sdk").AsTypeFunction<SlashRequest>;
+export declare const asSlashRequest: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.chain.slash.request" & {
+            readonly __schema: true;
+        };
+        accused: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        block: import('../../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        catalog: number;
+        chain: import("@ariestools/sdk").BrandedHex;
+        evidence: import("@ariestools/sdk").BrandedHash[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        $version?: number | undefined;
+        evm?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.chain.slash.request" & {
+            readonly __schema: true;
+        };
+        accused: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        block: import('../../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        catalog: number;
+        chain: import("@ariestools/sdk").BrandedHex;
+        evidence: import("@ariestools/sdk").BrandedHash[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        $version?: number | undefined;
+        evm?: number | undefined;
+    };
+};
+/** Coerces a value to SlashRequest or returns undefined if invalid. */
+export declare const toSlashRequest: {
+    (value: unknown): {
+        schema: "network.xyo.chain.slash.request" & {
+            readonly __schema: true;
+        };
+        accused: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        block: import('../../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        catalog: number;
+        chain: import("@ariestools/sdk").BrandedHex;
+        evidence: import("@ariestools/sdk").BrandedHash[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        $version?: number | undefined;
+        evm?: number | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        schema: "network.xyo.chain.slash.request" & {
+            readonly __schema: true;
+        };
+        accused: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        block: import('../../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        catalog: number;
+        chain: import("@ariestools/sdk").BrandedHex;
+        evidence: import("@ariestools/sdk").BrandedHash[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        $version?: number | undefined;
+        evm?: number | undefined;
+    };
+};
 //# sourceMappingURL=SlashRequestPayload.d.ts.map

package/dist/neutral/modules/protocol-model/payload/slash/SlashRequestPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SlashRequestPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashRequestPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAM5B,oDAAoD;AACpD,eAAO,MAAM,kBAAkB;;CAAoD,CAAA;AACnF,8CAA8C;AAC9C,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA;AAE1D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAiBhC,CAAA;AAEF,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE,gEAAgE;AAChE,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAAA;AAE1E,iEAAiE;AACjE,eAAO,MAAM,cAAc,oCAA8E,CAAA;AAEzG,qEAAqE;AACrE,eAAO,MAAM,cAAc,wDAAyC,CAAA"}
+{"version":3,"file":"SlashRequestPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashRequestPayload.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAM5B,oDAAoD;AACpD,eAAO,MAAM,kBAAkB;;CAAoD,CAAA;AACnF,8CAA8C;AAC9C,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA;AAE1D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAiBhC,CAAA;AAEF,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE,gEAAgE;AAChE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;iBAAgF,CAAA;AAE5G,gEAAgE;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,iEAAiE;AACjE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA;AAC3D,qEAAqE;AACrE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkD,CAAA;AAC7E,uEAAuE;AACvE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkD,CAAA"}

package/dist/neutral/modules/protocol-model/rejection/BlockRejectionPayload.d.ts

@@ -92,7 +92,7 @@ export declare const BlockRejectionZod: z.ZodMiniObject<{
 /** A block rejection payload representing a rejected block with reasons. */
 export type BlockRejection = z.infer<typeof BlockRejectionZod>;
 /** Type guard that checks if a value is a BlockRejection payload. */
-export declare const isBlockRejection: (x?: unknown) => x is {
+export declare const isBlockRejection: <T>(value: T) => value is T & {
     schema: "network.xyo.block.rejection" & {
         readonly __schema: true;
     };
@@ -137,48 +137,185 @@ export declare const isBlockRejection: (x?: unknown) => x is {
     $version?: number | undefined;
 };
 /** Casts a value to BlockRejection or returns undefined if invalid. */
-export declare const asBlockRejection: import("@ariestools/sdk").AsTypeFunction<{
-    schema: "network.xyo.block.rejection" & {
-        readonly __schema: true;
+export declare const asBlockRejection: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.block.rejection" & {
+            readonly __schema: true;
+        };
+        block: [{
+            $epoch: number;
+            block: import('../index.js').XL1BlockNumber;
+            chain: import("@ariestools/sdk").BrandedHex;
+            previous: import("@ariestools/sdk").BrandedHash | null;
+            schema: "network.xyo.boundwitness" & {
+                readonly __schema: true;
+            };
+            addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }))[];
+            payload_hashes: import("@ariestools/sdk").BrandedHash[];
+            payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
+            previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+            $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
+            $version?: 1000000 | undefined;
+            protocol?: number | undefined;
+            step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+            supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
+            $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }) | undefined;
+            $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        }, {
+            schema: import("@xyo-network/sdk").BrandedSchema<string>;
+            $version?: number | undefined;
+        }[]];
+        errors: {
+            [x: string]: unknown;
+            hash: import("@ariestools/sdk").BrandedHash;
+            name: string;
+            message?: string | undefined;
+        }[];
+        rejector: string;
+        $version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.block.rejection" & {
+            readonly __schema: true;
+        };
+        block: [{
+            $epoch: number;
+            block: import('../index.js').XL1BlockNumber;
+            chain: import("@ariestools/sdk").BrandedHex;
+            previous: import("@ariestools/sdk").BrandedHash | null;
+            schema: "network.xyo.boundwitness" & {
+                readonly __schema: true;
+            };
+            addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }))[];
+            payload_hashes: import("@ariestools/sdk").BrandedHash[];
+            payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
+            previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+            $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
+            $version?: 1000000 | undefined;
+            protocol?: number | undefined;
+            step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+            supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
+            $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }) | undefined;
+            $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        }, {
+            schema: import("@xyo-network/sdk").BrandedSchema<string>;
+            $version?: number | undefined;
+        }[]];
+        errors: {
+            [x: string]: unknown;
+            hash: import("@ariestools/sdk").BrandedHash;
+            name: string;
+            message?: string | undefined;
+        }[];
+        rejector: string;
+        $version?: number | undefined;
     };
-    block: [{
-        $epoch: number;
-        block: import('../index.js').XL1BlockNumber;
-        chain: import("@ariestools/sdk").BrandedHex;
-        previous: import("@ariestools/sdk").BrandedHash | null;
-        schema: "network.xyo.boundwitness" & {
+};
+/** Coerces a value to BlockRejection or returns undefined if invalid. */
+export declare const toBlockRejection: {
+    (value: unknown): {
+        schema: "network.xyo.block.rejection" & {
             readonly __schema: true;
         };
-        addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }))[];
-        payload_hashes: import("@ariestools/sdk").BrandedHash[];
-        payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
-        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
-        $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
-        $version?: 1000000 | undefined;
-        protocol?: number | undefined;
-        step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
-        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
-        $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | undefined;
-        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
-    }, {
-        schema: import("@xyo-network/sdk").BrandedSchema<string>;
+        block: [{
+            $epoch: number;
+            block: import('../index.js').XL1BlockNumber;
+            chain: import("@ariestools/sdk").BrandedHex;
+            previous: import("@ariestools/sdk").BrandedHash | null;
+            schema: "network.xyo.boundwitness" & {
+                readonly __schema: true;
+            };
+            addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }))[];
+            payload_hashes: import("@ariestools/sdk").BrandedHash[];
+            payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
+            previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+            $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
+            $version?: 1000000 | undefined;
+            protocol?: number | undefined;
+            step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+            supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
+            $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }) | undefined;
+            $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        }, {
+            schema: import("@xyo-network/sdk").BrandedSchema<string>;
+            $version?: number | undefined;
+        }[]];
+        errors: {
+            [x: string]: unknown;
+            hash: import("@ariestools/sdk").BrandedHash;
+            name: string;
+            message?: string | undefined;
+        }[];
+        rejector: string;
         $version?: number | undefined;
-    }[]];
-    errors: {
-        [x: string]: unknown;
-        hash: import("@ariestools/sdk").BrandedHash;
-        name: string;
-        message?: string | undefined;
-    }[];
-    rejector: string;
-    $version?: number | undefined;
-}>;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        schema: "network.xyo.block.rejection" & {
+            readonly __schema: true;
+        };
+        block: [{
+            $epoch: number;
+            block: import('../index.js').XL1BlockNumber;
+            chain: import("@ariestools/sdk").BrandedHex;
+            previous: import("@ariestools/sdk").BrandedHash | null;
+            schema: "network.xyo.boundwitness" & {
+                readonly __schema: true;
+            };
+            addresses: (import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }))[];
+            payload_hashes: import("@ariestools/sdk").BrandedHash[];
+            payload_schemas: import("@xyo-network/sdk").BrandedSchema<string>[];
+            previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+            $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
+            $version?: 1000000 | undefined;
+            protocol?: number | undefined;
+            step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+            supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
+            $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }) | undefined;
+            $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        }, {
+            schema: import("@xyo-network/sdk").BrandedSchema<string>;
+            $version?: number | undefined;
+        }[]];
+        errors: {
+            [x: string]: unknown;
+            hash: import("@ariestools/sdk").BrandedHash;
+            name: string;
+            message?: string | undefined;
+        }[];
+        rejector: string;
+        $version?: number | undefined;
+    };
+};
 //# sourceMappingURL=BlockRejectionPayload.d.ts.map

package/dist/neutral/modules/protocol-model/rejection/BlockRejectionPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockRejectionPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/rejection/BlockRejectionPayload.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAgD,CAAA;AACjF,6DAA6D;AAC7D,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D,uEAAuE;AACvE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAA;AAEF,yDAAyD;AACzD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG7B,CAAA;AAED,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,qEAAqE;AACrE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8D,CAAA;AAE3F,uEAAuE;AACvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2C,CAAA"}
+{"version":3,"file":"BlockRejectionPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/rejection/BlockRejectionPayload.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAgD,CAAA;AACjF,6DAA6D;AAC7D,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D,uEAAuE;AACvE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAA;AAEF,yDAAyD;AACzD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG7B,CAAA;AAED,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,qEAAqE;AACrE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkC,CAAA;AAC/D,uEAAuE;AACvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsD,CAAA;AACnF,yEAAyE;AACzE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsD,CAAA"}