@xyo-network/xl1-protocol 5.1.4 → 5.2.0

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

@@ -1,5 +1,6 @@
 export * from './application/index.js';
 export * from './elevatable/index.js';
+export * from './slash/index.js';
 export * from './StepIdentityPayload.js';
 export * from './StepWitness.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,kBAAkB,CAAA"}

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

@@ -0,0 +1,51 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Possible outcomes of adjudicating a slash request. */
+export declare const SlashOutcomes: readonly ["confirmed", "refuted", "indeterminate", "invalid"];
+/** The outcome of adjudicating a slash request. */
+export type SlashOutcome = typeof SlashOutcomes[number];
+/** Zod schema for a slash outcome. */
+export declare const SlashOutcomeZod: z.ZodMiniLiteral<"confirmed" | "refuted" | "indeterminate" | "invalid">;
+/** Schema identifier for slash adjudication payloads. */
+export declare const SlashAdjudicationSchema: "network.xyo.chain.slash.adjudication" & {
+    readonly __schema: true;
+};
+/** Schema type for slash adjudication payloads. */
+export type SlashAdjudicationSchema = typeof SlashAdjudicationSchema;
+/**
+ * Fields for the record that closes a slash request.
+ *
+ * Four outcomes, and the distinctions between them are the whole design. `confirmed` proceeds to
+ * a slash. `refuted` means counter-evidence held — the reporter was not wrong to ask.
+ * `indeterminate` means the check could not be completed from what was available, and costs
+ * nobody anything. Only `invalid` means the report was provably wrong, and only that opens a
+ * counter-slash against its filer.
+ *
+ * Collapsing the middle two into "failed" is what would make honest reporting dangerous: a
+ * reporter who hit a data-availability gap would be punished the same as one who fabricated.
+ */
+export declare const SlashAdjudicationFieldsZod: z.ZodMiniObject<{
+    claimant: z.ZodMiniOptional<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>>]>>;
+    claimantCommit: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    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>>]>;
+    outcome: z.ZodMiniLiteral<"confirmed" | "refuted" | "indeterminate" | "invalid">;
+    reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    request: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+/** Fields represented by the slash adjudication contract. */
+export type SlashAdjudicationFields = z.infer<typeof SlashAdjudicationFieldsZod>;
+/** A slash adjudication payload — the on-chain record closing a report. */
+export type SlashAdjudication = Payload<SlashAdjudicationFields, SlashAdjudicationSchema>;
+/** Type guard that checks if a value is a valid SlashAdjudication. */
+export declare const isSlashAdjudication: (x?: unknown) => x is SlashAdjudication;
+/** Casts a value to SlashAdjudication or returns undefined if invalid. */
+export declare const asSlashAdjudication: import("@ariestools/sdk").AsTypeFunction<SlashAdjudication>;
+//# sourceMappingURL=SlashAdjudicationPayload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SlashAdjudicationPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashAdjudicationPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,yDAAyD;AACzD,eAAO,MAAM,aAAa,+DAAgE,CAAA;AAE1F,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,MAAM,CAAC,CAAA;AAEvD,sCAAsC;AACtC,eAAO,MAAM,eAAe,yEAA2B,CAAA;AAEvD,yDAAyD;AACzD,eAAO,MAAM,uBAAuB;;CAAyD,CAAA;AAC7F,mDAAmD;AACnD,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAA;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;iBAarC,CAAA;AAEF,6DAA6D;AAC7D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,2EAA2E;AAC3E,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,uBAAuB,EAAE,uBAAuB,CAAC,CAAA;AAEzF,sEAAsE;AACtE,eAAO,MAAM,mBAAmB,yCAG/B,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,6DAA8C,CAAA"}

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

@@ -0,0 +1,33 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Schema identifier for slash challenge payloads. */
+export declare const SlashChallengeSchema: "network.xyo.chain.slash.challenge" & {
+    readonly __schema: true;
+};
+/** Schema type for slash challenge payloads. */
+export type SlashChallengeSchema = typeof SlashChallengeSchema;
+/**
+ * Fields for a challenge to a slash request.
+ *
+ * Anyone may challenge and no bond is required, because a challenge can only exculpate. A
+ * frivolous one fails to change the verdict and costs its filer the fee; there is no version of
+ * it that harms the accused, so there is nothing to deter.
+ */
+export declare const SlashChallengeFieldsZod: z.ZodMiniObject<{
+    evidence: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    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>>]>;
+    request: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+/** Fields represented by the slash challenge contract. */
+export type SlashChallengeFields = z.infer<typeof SlashChallengeFieldsZod>;
+/** A slash challenge payload — counter-evidence against a pending report. */
+export type SlashChallenge = Payload<SlashChallengeFields, SlashChallengeSchema>;
+/** Type guard that checks if a value is a valid SlashChallenge. */
+export declare const isSlashChallenge: (x?: unknown) => x is SlashChallenge;
+/** Casts a value to SlashChallenge or returns undefined if invalid. */
+export declare const asSlashChallenge: import("@ariestools/sdk").AsTypeFunction<SlashChallenge>;
+//# sourceMappingURL=SlashChallengePayload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SlashChallengePayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashChallengePayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAsD,CAAA;AACvF,gDAAgD;AAChD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBAOlC,CAAA;AAEF,0DAA0D;AAC1D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,oBAAoB,EAAE,oBAAoB,CAAC,CAAA;AAEhF,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,sCAAoF,CAAA;AAEjH,uEAAuE;AACvE,eAAO,MAAM,gBAAgB,0DAA2C,CAAA"}

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

@@ -0,0 +1,35 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Schema identifier for slash commit payloads. */
+export declare const SlashCommitSchema: "network.xyo.chain.slash.commit" & {
+    readonly __schema: true;
+};
+/** Schema type for slash commit payloads. */
+export type SlashCommitSchema = typeof SlashCommitSchema;
+/**
+ * Fields for a slash commitment.
+ *
+ * A report's evidence becomes public the moment it is recorded, and whoever orders the next block
+ * decides which copy of it lands first. Committing to the report before revealing it is what
+ * stops a reporter's work from being lifted and re-filed under someone else's name.
+ *
+ * The commitment is the hash of the whole report, so it binds the reporter, the accused, the
+ * offense, and the evidence together — none of them can be swapped after the fact.
+ */
+export declare const SlashCommitFieldsZod: z.ZodMiniObject<{
+    commitment: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    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>;
+/** Fields represented by the slash commit contract. */
+export type SlashCommitFields = z.infer<typeof SlashCommitFieldsZod>;
+/** A slash commit payload — reserves a report before its evidence is public. */
+export type SlashCommit = Payload<SlashCommitFields, SlashCommitSchema>;
+/** Type guard that checks if a value is a valid SlashCommit. */
+export declare const isSlashCommit: (x?: unknown) => x is SlashCommit;
+/** Casts a value to SlashCommit or returns undefined if invalid. */
+export declare const asSlashCommit: import("@ariestools/sdk").AsTypeFunction<SlashCommit>;
+//# sourceMappingURL=SlashCommitPayload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SlashCommitPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashCommitPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,mDAAmD;AACnD,eAAO,MAAM,iBAAiB;;CAAmD,CAAA;AACjF,6CAA6C;AAC7C,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;;;;;iBAK/B,CAAA;AAEF,uDAAuD;AACvD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAA;AAEvE,gEAAgE;AAChE,eAAO,MAAM,aAAa,mCAA2E,CAAA;AAErG,oEAAoE;AACpE,eAAO,MAAM,aAAa,uDAAwC,CAAA"}

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

@@ -0,0 +1,33 @@
+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" & {
+    readonly __schema: true;
+};
+/** Schema type for slash evidence payloads. */
+export type SlashEvidenceSchema = typeof SlashEvidenceSchema;
+/**
+ * Fields for a slash evidence container.
+ *
+ * Evidence is signed bound witnesses — blocks, transactions, attestations. Those cannot ride
+ * on-chain as bare payloads, because a bound witness in a block's payload set would be read as
+ * one of that block's transactions. Carrying them inside an opaque container keeps them verbatim,
+ * which matters: the whole point of the evidence is that its signatures still verify.
+ */
+export declare const SlashEvidenceFieldsZod: z.ZodMiniObject<{
+    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>;
+/** 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>;
+/** Type guard that checks if a value is a valid SlashEvidence. */
+export declare const isSlashEvidence: (x?: unknown) => x is SlashEvidence;
+/** Casts a value to SlashEvidence or returns undefined if invalid. */
+export declare const asSlashEvidence: import("@ariestools/sdk").AsTypeFunction<SlashEvidence>;
+//# sourceMappingURL=SlashEvidencePayload.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,46 @@
+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" & {
+    readonly __schema: true;
+};
+/** Schema type for slash request payloads. */
+export type SlashRequestSchema = typeof SlashRequestSchema;
+/**
+ * Fields for a slash request — an accusation that a specific address committed a specific offense.
+ *
+ * A request carries no argument, only artifacts and a catalog entry. If an offense cannot be
+ * expressed that way it is not reportable, which is what keeps accusation mechanical: the same
+ * request produces the same verdict for anyone who checks it, and there is nothing to be
+ * persuaded by.
+ *
+ * Every offense locates at exactly one height, so there is no range to disagree about when
+ * deciding whether two reports are the same accusation.
+ */
+export declare const SlashRequestFieldsZod: z.ZodMiniObject<{
+    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>;
+/** 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>;
+/** Type guard that checks if a value is a valid SlashRequest. */
+export declare const isSlashRequest: (x?: unknown) => x is SlashRequest;
+/** Casts a value to SlashRequest or returns undefined if invalid. */
+export declare const asSlashRequest: import("@ariestools/sdk").AsTypeFunction<SlashRequest>;
+//# sourceMappingURL=SlashRequestPayload.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,6 @@
+export * from './SlashAdjudicationPayload.js';
+export * from './SlashChallengePayload.js';
+export * from './SlashCommitPayload.js';
+export * from './SlashEvidencePayload.js';
+export * from './SlashRequestPayload.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,2BAA2B,CAAA;AACzC,cAAc,0BAA0B,CAAA"}

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

@@ -14,6 +14,7 @@ export declare const BlockRejectionFieldsZod: z.ZodMiniObject<{
         previous: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         step_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;
@@ -54,6 +55,7 @@ export declare const BlockRejectionZod: z.ZodMiniObject<{
         previous: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         step_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;
@@ -108,6 +110,7 @@ export declare const isBlockRejection: (x?: unknown) => x is {
         $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
         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;
         } & {
@@ -149,6 +152,7 @@ export declare const asBlockRejection: import("@ariestools/sdk").AsTypeFunction<
         $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
         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;
         } & {

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8D,CAAA;AAE3F,uEAAuE;AACvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2C,CAAA"}