@xyo-network/chain-sdk 5.0.4 → 5.1.0

package/dist/node/modules/slashing/model/OffenseVerificationContext.d.ts

@@ -0,0 +1,88 @@
+import type { Hash, Hex, JsonObject, Promisable } from '@ariestools/sdk';
+import type { AccountBalanceViewer, ChainParams, SignedHydratedBlockWithHashMeta, StakeSnapshotViewerMethods, XL1BlockNumber } from '@xyo-network/xl1-sdk';
+import type { SlashHistoryReader } from './SlashHistoryReader.js';
+/**
+ * The verifier's own view of finalized history.
+ *
+ * Every method may answer `undefined`, and that answer always means the same thing: this verifier
+ * cannot see far enough to judge. Callers map it to `indeterminate` rather than guessing, because
+ * a verifier that treats "I cannot see it" as "it did not happen" convicts people for its own
+ * pruning policy.
+ */
+export interface CanonicalChainReader {
+    /** The finalized block at a height, or undefined when it is not resolvable. */
+    blockAtHeight(height: XL1BlockNumber): Promisable<SignedHydratedBlockWithHashMeta | undefined>;
+    /** A finalized block by hash, or undefined when it is not resolvable. */
+    blockByHash(hash: Hash): Promisable<SignedHydratedBlockWithHashMeta | undefined>;
+    /** The current finalized head, or undefined when it is not resolvable. */
+    finalizedHead(): Promisable<SignedHydratedBlockWithHashMeta | undefined>;
+    /**
+     * The EVM anchor in force at an XL1 height, taken from the nearest ancestor that carries one.
+     *
+     * Blocks are not required to carry an anchor below the anchor rules, so the nearest ancestor is
+     * the only reading that gives the same answer on every conforming node.
+     */
+    validatedAnchorAt(height: XL1BlockNumber): Promisable<number | undefined>;
+}
+/**
+ * A read-only view of the backing EVM chain.
+ *
+ * `head()` is deliberately narrow in what it may decide. It answers whether a fact has had time to
+ * settle — never what the fact is. A verdict that turned on an unanchored local head would differ
+ * between nodes purely by who asked when.
+ */
+export interface EvmView {
+    /** The canonical hash at an EVM height, or undefined when it is not resolvable. */
+    canonicalHashAt(evmBlock: number): Promisable<Hex | undefined>;
+    /** The current EVM head, used only to decide whether something has matured. */
+    head(): Promisable<number | undefined>;
+}
+/** Where the report under verification entered the chain. */
+export interface SubmissionContext {
+    /** Height of the block carrying the commitment, when the report was committed first. */
+    commitCarryingHeight?: XL1BlockNumber;
+    /** Height of the block carrying the request. */
+    requestCarryingHeight: XL1BlockNumber;
+}
+/**
+ * Everything a verification procedure is allowed to consult.
+ *
+ * This interface is the purity boundary. A procedure gets narrow readers and nothing else — no
+ * wall clock, no ambient network, no node-local state — so that two honest verifiers holding the
+ * same finalized history reach the same verdict. Slashing is only safe if that holds; a procedure
+ * that could read anything ambient would let two nodes convict different people from the same
+ * evidence.
+ */
+export interface OffenseVerificationContext {
+    /** The artifacts the report cited, keyed by their recomputed data hash. */
+    artifacts: ReadonlyMap<Hash, JsonObject>;
+    /**
+     * Balances as this verifier's canonical history has them, absent when it cannot read them.
+     *
+     * Only ever consulted against canonical history. Replaying a balance rule over state the
+     * reporter supplied would let a report carry its own proof.
+     */
+    balances?: AccountBalanceViewer;
+    /**
+     * The block reward the staking contract allowed at an EVM height, when the register sources
+     * rewards from the contract and this verifier can read it.
+     *
+     * Evaluated at an anchor rather than at a local head, so the answer is the same for everyone.
+     */
+    blockRewardAt?: (evmBlock: number) => Promisable<bigint | undefined>;
+    /** Offense catalog version the report was filed under. */
+    catalogVersion: number;
+    /** The verifier's canonical finalized chain. */
+    chain: CanonicalChainReader;
+    /** The backing EVM chain, absent when this verifier has no EVM view. */
+    evm?: EvmView;
+    /** Finalized slash traffic, for duplicate and re-litigation checks. */
+    history: SlashHistoryReader;
+    /** The register version covering the offense height. */
+    params: ChainParams;
+    /** Stake as measured at an EVM height, absent when unavailable. */
+    snapshot?: StakeSnapshotViewerMethods;
+    /** Where the report entered the chain. */
+    submission: SubmissionContext;
+}
+//# sourceMappingURL=OffenseVerificationContext.d.ts.map

package/dist/node/modules/slashing/model/OffenseVerificationContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OffenseVerificationContext.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/model/OffenseVerificationContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EAAE,GAAG,EAAE,UAAU,EAAE,UAAU,EAClC,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EACV,oBAAoB,EAAE,WAAW,EAAE,+BAA+B,EAClE,0BAA0B,EAAE,cAAc,EAC3C,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,+EAA+E;IAC/E,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,UAAU,CAAC,+BAA+B,GAAG,SAAS,CAAC,CAAA;IAC9F,yEAAyE;IACzE,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,CAAC,+BAA+B,GAAG,SAAS,CAAC,CAAA;IAChF,0EAA0E;IAC1E,aAAa,IAAI,UAAU,CAAC,+BAA+B,GAAG,SAAS,CAAC,CAAA;IACxE;;;;;OAKG;IACH,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,UAAU,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CAC1E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,mFAAmF;IACnF,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC,GAAG,GAAG,SAAS,CAAC,CAAA;IAC9D,+EAA+E;IAC/E,IAAI,IAAI,UAAU,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CACvC;AAED,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC,wFAAwF;IACxF,oBAAoB,CAAC,EAAE,cAAc,CAAA;IACrC,gDAAgD;IAChD,qBAAqB,EAAE,cAAc,CAAA;CACtC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,0BAA0B;IACzC,2EAA2E;IAC3E,SAAS,EAAE,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,oBAAoB,CAAA;IAC/B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,UAAU,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IACpE,0DAA0D;IAC1D,cAAc,EAAE,MAAM,CAAA;IACtB,gDAAgD;IAChD,KAAK,EAAE,oBAAoB,CAAA;IAC3B,wEAAwE;IACxE,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,uEAAuE;IACvE,OAAO,EAAE,kBAAkB,CAAA;IAC3B,wDAAwD;IACxD,MAAM,EAAE,WAAW,CAAA;IACnB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,0BAA0B,CAAA;IACrC,0CAA0C;IAC1C,UAAU,EAAE,iBAAiB,CAAA;CAC9B"}

package/dist/node/modules/slashing/model/SlashHistoryReader.d.ts

@@ -0,0 +1,34 @@
+import type { Hash, Promisable } from '@ariestools/sdk';
+import type { SlashAdjudication, SlashChallenge, SlashCommit, SlashRequest, XL1BlockNumber } from '@xyo-network/xl1-sdk';
+import type { OffenseKey } from './offenseKey.js';
+/** A slash payload as it was actually recorded, with where it landed. */
+export interface Finalized<T> {
+    /** EVM anchor in force at the carrying block. */
+    anchor?: number;
+    /** Height of the block that carried it. */
+    carryingHeight: XL1BlockNumber;
+    /** Hash of the payload itself. */
+    hash: Hash;
+    /** Position within the carrying block, which breaks ties between same-block entries. */
+    index: number;
+    /** The recorded payload. */
+    payload: T;
+}
+/**
+ * Finalized slash traffic, as one verifier can see it.
+ *
+ * Reads answer from finalized history only. A verifier that counted pending traffic could reach a
+ * verdict its peers cannot reproduce, and the whole point of these procedures is that two honest
+ * nodes agree.
+ */
+export interface SlashHistoryReader {
+    /** The adjudication closing an offense, when one is finalized. */
+    adjudicationByKey(key: OffenseKey): Promisable<Finalized<SlashAdjudication> | undefined>;
+    /** Challenges filed against a request. */
+    challengesForRequest(requestHash: Hash): Promisable<Finalized<SlashChallenge>[]>;
+    /** Commitments naming a given report hash. */
+    commitsMatching(commitment: Hash): Promisable<Finalized<SlashCommit>[]>;
+    /** Requests already recorded for an offense, earliest first. */
+    requestsByKey(key: OffenseKey): Promisable<Finalized<SlashRequest>[]>;
+}
+//# sourceMappingURL=SlashHistoryReader.d.ts.map

package/dist/node/modules/slashing/model/SlashHistoryReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlashHistoryReader.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/model/SlashHistoryReader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EACV,iBAAiB,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAC7E,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,yEAAyE;AACzE,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,2CAA2C;IAC3C,cAAc,EAAE,cAAc,CAAA;IAC9B,kCAAkC;IAClC,IAAI,EAAE,IAAI,CAAA;IACV,wFAAwF;IACxF,KAAK,EAAE,MAAM,CAAA;IACb,4BAA4B;IAC5B,OAAO,EAAE,CAAC,CAAA;CACX;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,kEAAkE;IAClE,iBAAiB,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAC,CAAA;IACxF,0CAA0C;IAC1C,oBAAoB,CAAC,WAAW,EAAE,IAAI,GAAG,UAAU,CAAC,SAAS,CAAC,cAAc,CAAC,EAAE,CAAC,CAAA;IAChF,8CAA8C;IAC9C,eAAe,CAAC,UAAU,EAAE,IAAI,GAAG,UAAU,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,CAAC,CAAA;IACvE,gEAAgE;IAChE,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC,CAAA;CACtE"}

package/dist/node/modules/slashing/model/VerificationOutcome.d.ts

@@ -0,0 +1,39 @@
+import type { JsonObject } from '@ariestools/sdk';
+/**
+ * What verifying a report concluded.
+ *
+ * Three outcomes rather than two, and the middle one carries the design. `indeterminate` means the
+ * check could not be completed from what was available — a reader was unreachable, history had
+ * aged out, an anchor had not matured. Collapsing it into `provably-invalid` would punish an
+ * honest reporter for a gap in someone else's data, which is the fastest way to make reporting
+ * something nobody sane volunteers for.
+ */
+export declare const VerificationOutcomes: readonly ["verified", "indeterminate", "provably-invalid"];
+/** The conclusion of a verification procedure. */
+export type VerificationOutcome = typeof VerificationOutcomes[number];
+/**
+ * The result of verifying one report.
+ *
+ * The transcript is not decoration. Every procedure is required to be reproducible by anyone
+ * holding the same inputs, so it records what was consulted and what was recomputed — that record
+ * is what an arbiter publishes, and what lets two nodes that disagree find out which of them is
+ * reading different data rather than arguing about conclusions.
+ */
+export interface OffenseVerdict {
+    /** The conclusion. */
+    outcome: VerificationOutcome;
+    /**
+     * Set when the verdict rests on absence rather than evidence.
+     *
+     * A conclusion drawn from not finding something can be overturned by someone who has it, so the
+     * adjudication side has to know the difference before it acts.
+     */
+    provisional?: boolean;
+    /** Why the procedure concluded what it did. */
+    reason: string;
+    /** Step-by-step record of inputs consulted and values recomputed. */
+    transcript: JsonObject;
+}
+/** Builds a verdict, keeping the transcript shape uniform across procedures. */
+export declare function verdict(outcome: VerificationOutcome, reason: string, transcript?: JsonObject, provisional?: boolean): OffenseVerdict;
+//# sourceMappingURL=VerificationOutcome.d.ts.map

package/dist/node/modules/slashing/model/VerificationOutcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VerificationOutcome.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/model/VerificationOutcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,4DAA6D,CAAA;AAE9F,kDAAkD;AAClD,MAAM,MAAM,mBAAmB,GAAG,OAAO,oBAAoB,CAAC,MAAM,CAAC,CAAA;AAErE;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,sBAAsB;IACtB,OAAO,EAAE,mBAAmB,CAAA;IAC5B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAA;IACd,qEAAqE;IACrE,UAAU,EAAE,UAAU,CAAA;CACvB;AAED,gFAAgF;AAChF,wBAAgB,OAAO,CACrB,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,UAAe,EAC3B,WAAW,CAAC,EAAE,OAAO,GACpB,cAAc,CAQhB"}

package/dist/node/modules/slashing/model/index.d.ts

@@ -0,0 +1,6 @@
+export * from './offenseKey.js';
+export * from './OffenseProcedure.js';
+export * from './OffenseVerificationContext.js';
+export * from './SlashHistoryReader.js';
+export * from './VerificationOutcome.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/modules/slashing/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA"}

package/dist/node/modules/slashing/model/offenseKey.d.ts

@@ -0,0 +1,42 @@
+import type { XyoAddress } from '@xyo-network/sdk';
+import type { ChainId, OffenseCode, SlashRequest, XL1BlockNumber } from '@xyo-network/xl1-sdk';
+/**
+ * What makes two reports be about the same offense.
+ *
+ * Duplicate reports are expected — several validators watching the same chain will see the same
+ * misconduct — so the system has to recognise them as one thing. Without a canonical key, the same
+ * offense could be adjudicated twice and slashed twice.
+ */
+export interface OffenseKey {
+    /** Who is accused. */
+    accused: XyoAddress;
+    /** The canonical height the offense is located at. */
+    block: XL1BlockNumber;
+    /** The chain it happened on. */
+    chain: ChainId;
+    /** Which offense class. */
+    offense: OffenseCode;
+}
+/** The key a request is filed under. */
+export declare function offenseKeyOf(request: SlashRequest): OffenseKey;
+/**
+ * A stable string for the key, for use as a map key.
+ *
+ * Field order is fixed rather than derived from object iteration, so the same offense produces the
+ * same string on every node regardless of how the object was built.
+ */
+export declare function offenseKeyString(key: OffenseKey): string;
+/**
+ * Where an offense is located on the chain, which is not always where it was reported.
+ *
+ * Each class has one canonical height, and it is the height the report's `block` field must carry.
+ * Fixing it per class is what stops the same misconduct being filed under several different
+ * heights and slashed once for each.
+ *
+ * - equivocation — the height the two candidates compete at
+ * - invalid-block, reward-overmint, false-anchor, ineligible-production — the offending block
+ * - invalid-slash-request — the height carrying the request being complained about
+ * - false-attestation — the height carrying the attestation
+ */
+export declare function canonicalOffenseHeight(request: SlashRequest): XL1BlockNumber;
+//# sourceMappingURL=offenseKey.d.ts.map

package/dist/node/modules/slashing/model/offenseKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offenseKey.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/model/offenseKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EACV,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EACnD,MAAM,sBAAsB,CAAA;AAE7B;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,sBAAsB;IACtB,OAAO,EAAE,UAAU,CAAA;IACnB,sDAAsD;IACtD,KAAK,EAAE,cAAc,CAAA;IACrB,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAA;IACd,2BAA2B;IAC3B,OAAO,EAAE,WAAW,CAAA;CACrB;AAED,wCAAwC;AACxC,wBAAgB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,UAAU,CAO9D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAExD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,YAAY,GAAG,cAAc,CAE5E"}

package/dist/node/modules/slashing/verify/index.d.ts

@@ -0,0 +1,10 @@
+export * from './preamble.js';
+export * from './verifyEquivocation.js';
+export * from './verifyFalseAnchor.js';
+export * from './verifyFalseAttestation.js';
+export * from './verifyIneligibleProduction.js';
+export * from './verifyInvalidBlock.js';
+export * from './verifyInvalidSlashRequest.js';
+export * from './verifyOffense.js';
+export * from './verifyRewardOvermint.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/modules/slashing/verify/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,yBAAyB,CAAA;AACvC,cAAc,wBAAwB,CAAA;AACtC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,yBAAyB,CAAA;AACvC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,oBAAoB,CAAA;AAClC,cAAc,2BAA2B,CAAA"}

package/dist/node/modules/slashing/verify/preamble.d.ts

@@ -0,0 +1,63 @@
+import type { Hash, JsonObject } from '@ariestools/sdk';
+import type { SlashRequest } from '@xyo-network/xl1-sdk';
+import type { VerifiedArtifact } from '../model/OffenseProcedure.js';
+import type { OffenseVerificationContext } from '../model/OffenseVerificationContext.js';
+import type { OffenseVerdict } from '../model/VerificationOutcome.js';
+/** What re-checking a report's cited artifacts concluded. */
+export type ArtifactCheck = {
+    byHash: Map<Hash, VerifiedArtifact>;
+    ok: true;
+} | {
+    missing?: boolean;
+    ok: false;
+    reason: string;
+};
+/**
+ * Re-derives every cited artifact's identity and checks its signatures.
+ *
+ * Identity is recomputed, never taken from the report. A reporter naming a hash it did not supply
+ * is asserting something no one can check, and accepting that claim is how a fabricated report
+ * would pass — the artifact has to hash to the thing it was cited as.
+ *
+ * Signature failures are provably invalid rather than indeterminate: nothing about a bad signature
+ * depends on what this verifier can see, so every honest verifier reaches the same conclusion. An
+ * artifact this verifier simply cannot see is the opposite case — `missing` marks it, and callers
+ * map it to indeterminate, because what a verifier failed to retain says nothing about a reporter.
+ * @param artifacts The artifacts supplied with the report, keyed by claimed hash
+ * @param referenced The hashes the report cited
+ * @returns The artifacts by recomputed hash, or why the citation failed
+ */
+export declare function verifyArtifacts(artifacts: ReadonlyMap<Hash, JsonObject>, referenced: readonly Hash[]): Promise<ArtifactCheck>;
+/**
+ * Whether a signed reference points at this artifact.
+ *
+ * Signed documents reference each other by hash, but which form — data or meta-inclusive —
+ * depends on who wrote the reference. Both are recomputed from the artifact itself, so a match
+ * never rests on a hash the supplier merely claimed.
+ */
+export declare function referencesArtifact(reference: Hash | null | undefined, artifact: VerifiedArtifact): Promise<boolean>;
+/** How the freshness gate resolved, and the anchors it measured between. */
+export interface FreshnessResult {
+    /** EVM anchor at the offense. */
+    eOff?: number;
+    /** EVM anchor at submission. */
+    eSub?: number;
+    /** Why it concluded what it did. */
+    reason: string;
+    /** Set when the report cannot proceed. */
+    verdict?: OffenseVerdict;
+}
+/**
+ * Whether a report was filed while its offense was still fresh.
+ *
+ * Both ends are measured on the EVM clock rather than the chain's own, because the chain's clock
+ * is exactly what a misbehaving producer controls. Anchors are what a reporter cannot forge.
+ *
+ * An unresolvable anchor is indeterminate, not stale: a verifier that has pruned the history is
+ * making a statement about itself, not about the reporter.
+ * @param ctx What the verifier may consult
+ * @param request The report being checked
+ * @returns The measured anchors, and a verdict when the report cannot proceed
+ */
+export declare function freshnessGate(ctx: OffenseVerificationContext, request: SlashRequest): Promise<FreshnessResult>;
+//# sourceMappingURL=preamble.d.ts.map

package/dist/node/modules/slashing/verify/preamble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/preamble.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAGvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAGxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACpE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wCAAwC,CAAA;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAGrE,6DAA6D;AAC7D,MAAM,MAAM,aAAa,GACnB;IAAE,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;IAAC,EAAE,EAAE,IAAI,CAAA;CAAE,GACjD;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,EACxC,UAAU,EAAE,SAAS,IAAI,EAAE,GAC1B,OAAO,CAAC,aAAa,CAAC,CA0BxB;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAKzH;AAED,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAA;IACd,0CAA0C;IAC1C,OAAO,CAAC,EAAE,cAAc,CAAA;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,0BAA0B,EAC/B,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,eAAe,CAAC,CAgC1B"}

package/dist/node/modules/slashing/verify/verifyEquivocation.d.ts

@@ -0,0 +1,19 @@
+import type { OffenseProcedure } from '../model/OffenseProcedure.js';
+/**
+ * O1 — equivocation: signing two competing candidates for the same slot.
+ *
+ * Producing two blocks is not by itself misconduct. A producer whose candidate goes stale is
+ * expected to re-propose, and the honest way to do that is to say which candidate the new one
+ * replaces. What this procedure looks for is two candidates that compete without any such
+ * statement.
+ *
+ * It is deliberately self-contained: everything it needs is in the two artifacts, so it never
+ * returns indeterminate. Two verifiers holding the same pair always agree, which matters because
+ * this is the offense most likely to be reported by someone with a partial view of the chain.
+ *
+ * The accused's own defense — producing the missing link later — is not evaluated here. That
+ * arrives during the challenge window and is an adjudication-level `refuted`, not a reason for
+ * this procedure to withhold a verdict.
+ */
+export declare const verifyEquivocation: OffenseProcedure;
+//# sourceMappingURL=verifyEquivocation.d.ts.map

package/dist/node/modules/slashing/verify/verifyEquivocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyEquivocation.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/verifyEquivocation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,8BAA8B,CAAA;AActF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,EAAE,gBAmDhC,CAAA"}

package/dist/node/modules/slashing/verify/verifyFalseAnchor.d.ts

@@ -0,0 +1,15 @@
+import type { OffenseProcedure } from '../model/OffenseProcedure.js';
+/**
+ * O4 — false anchor: pointing a block at an EVM block that is not where it says it is.
+ *
+ * Two shapes, and they differ in what they cost to prove. An anchor that moves backwards is
+ * settled by the two blocks alone: the chain's anchor is required to be monotonic, so a child
+ * claiming an earlier height than its parent contradicts itself, and no external view is needed.
+ *
+ * The other shape — an anchor naming a hash the EVM never had at that height — needs the EVM
+ * itself, and it needs to have settled. Judging before the maturity depth has passed would let a
+ * reorg convict an honest producer for a block that was canonical when it anchored. Until then the
+ * answer is that it is too early to say, which is not the same as saying nothing happened.
+ */
+export declare const verifyFalseAnchor: OffenseProcedure;
+//# sourceMappingURL=verifyFalseAnchor.d.ts.map

package/dist/node/modules/slashing/verify/verifyFalseAnchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyFalseAnchor.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/verifyFalseAnchor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,8BAA8B,CAAA;AAmDtF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,EAAE,gBAmD/B,CAAA"}

package/dist/node/modules/slashing/verify/verifyFalseAttestation.d.ts

@@ -0,0 +1,22 @@
+import type { OffenseProcedure } from '../model/OffenseProcedure.js';
+/**
+ * O7 — false attestation: signing an attestation for a step that says something else.
+ *
+ * Two branches, and the second one is weaker than the first on purpose.
+ *
+ * When the attested block is supplied, the question is closed: the block states its own step
+ * hashes, so an attestation naming a different one at the attested level contradicts a signed
+ * document and nothing external is needed. Self-contained claims are judged before any retention
+ * arithmetic — a contradiction between two supplied documents does not age out.
+ *
+ * When no block is supplied, the claim is that the attested block never existed. That is a claim
+ * about absence, and absence is exactly what a verifier with an incomplete view would also see.
+ * A verdict here is therefore marked provisional: it is enough to open the question, not to close
+ * it, and whoever adjudicates has to let the accused produce the block before acting.
+ *
+ * Past the retention window the absence claim is indeterminate rather than provisional. Once the
+ * chain no longer requires anyone to hold the block, absence stops being evidence of anything at
+ * all — treating it as proof would turn the retention policy into a conviction engine.
+ */
+export declare const verifyFalseAttestation: OffenseProcedure;
+//# sourceMappingURL=verifyFalseAttestation.d.ts.map

package/dist/node/modules/slashing/verify/verifyFalseAttestation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyFalseAttestation.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/verifyFalseAttestation.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,8BAA8B,CAAA;AAqCtF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,sBAAsB,EAAE,gBA4DpC,CAAA"}

package/dist/node/modules/slashing/verify/verifyIneligibleProduction.d.ts

@@ -0,0 +1,18 @@
+import type { OffenseProcedure } from '../model/OffenseProcedure.js';
+/**
+ * O5 — ineligible production: producing a block without the standing to produce it.
+ *
+ * The measurement point is recomputed from the two blocks' own signed anchors rather than taken
+ * from the report or from a live EVM head. That is what makes admission and after-the-fact
+ * verification ask the same question: a block that was admissible when it was produced must not
+ * become an offense later because stake moved in the meantime.
+ *
+ * Both halves of the predicate matter. Stake alone says an address *could* participate; the intent
+ * declaration is how it says it *is*. Seasoning is what stops standing being rented for a block.
+ *
+ * Everything here depends on external state — stake as it stood at an EVM height — so an
+ * unreadable snapshot is indeterminate. A verifier without that history has no opinion, and
+ * pretending otherwise would convict on the basis of not having looked.
+ */
+export declare const verifyIneligibleProduction: OffenseProcedure;
+//# sourceMappingURL=verifyIneligibleProduction.d.ts.map

package/dist/node/modules/slashing/verify/verifyIneligibleProduction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyIneligibleProduction.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/verifyIneligibleProduction.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,8BAA8B,CAAA;AAwCtF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,EAAE,gBA+CxC,CAAA"}

package/dist/node/modules/slashing/verify/verifyInvalidBlock.d.ts

@@ -0,0 +1,18 @@
+import type { OffenseProcedure } from '../model/OffenseProcedure.js';
+/**
+ * O2 — invalid block: finalizing a block that breaks the rules in force at its height.
+ *
+ * Only rules that reproduce identically on every node are replayed. Admission gates are excluded
+ * by construction: whether a candidate was admitted depends on what a particular node had in its
+ * pool at a particular moment, so re-running one later would convict a producer for someone
+ * else's timing.
+ *
+ * Nothing the reporter supplied is trusted as state. The parent and the balances come from this
+ * verifier's own canonical history, because a report that carried its own version of history
+ * could prove anything it liked.
+ *
+ * An unresolvable parent is indeterminate rather than a finding. A verifier that has pruned past
+ * the offense knows nothing about the block — that is a fact about the verifier.
+ */
+export declare const verifyInvalidBlock: OffenseProcedure;
+//# sourceMappingURL=verifyInvalidBlock.d.ts.map

package/dist/node/modules/slashing/verify/verifyInvalidBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyInvalidBlock.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/verifyInvalidBlock.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,8BAA8B,CAAA;AAgDtF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,EAAE,gBA0ChC,CAAA"}

package/dist/node/modules/slashing/verify/verifyInvalidSlashRequest.d.ts

@@ -0,0 +1,11 @@
+import type { OffenseCode } from '@xyo-network/xl1-sdk';
+import type { OffenseProcedure } from '../model/OffenseProcedure.js';
+/**
+ * Builds the invalid-slash-request procedure over a registry it resolves at call time.
+ *
+ * The registry is passed as a thunk rather than imported, because this procedure lives inside the
+ * same registry it needs. Deferring the lookup keeps that self-reference within one module instead
+ * of turning it into an import cycle between two.
+ */
+export declare function createVerifyInvalidSlashRequest(resolve: () => Partial<Record<OffenseCode, OffenseProcedure>>): OffenseProcedure;
+//# sourceMappingURL=verifyInvalidSlashRequest.d.ts.map

package/dist/node/modules/slashing/verify/verifyInvalidSlashRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyInvalidSlashRequest.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/verifyInvalidSlashRequest.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,sBAAsB,CAAA;AAIrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AAYpE;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC,GAC5D,gBAAgB,CAkFlB"}

package/dist/node/modules/slashing/verify/verifyOffense.d.ts

@@ -0,0 +1,29 @@
+import type { OffenseCode, SlashRequest } from '@xyo-network/xl1-sdk';
+import type { OffenseProcedure } from '../model/OffenseProcedure.js';
+import type { OffenseVerificationContext } from '../model/OffenseVerificationContext.js';
+import type { OffenseVerdict } from '../model/VerificationOutcome.js';
+/**
+ * The procedure for each offense class.
+ *
+ * Exported as a map so a class can be verified in isolation by conformance tests, and so the
+ * invalid-slash-request procedure can recurse back through it to re-run the report it is
+ * complaining about.
+ */
+export declare const offenseProcedures: Partial<Record<OffenseCode, OffenseProcedure>>;
+/**
+ * Verifies one report, end to end.
+ *
+ * The shared preamble runs first for every class: cited artifacts are re-hashed and their
+ * signatures checked, then the offense is measured against the freshness window. Both are
+ * conditions no class can waive, so running them once here keeps a procedure from quietly
+ * skipping one.
+ *
+ * A class with no registered procedure is indeterminate rather than invalid. The register can
+ * activate a class this build does not implement, and refusing to conclude is the honest answer —
+ * concluding "not an offense" would let the gap read as an acquittal.
+ * @param ctx What the verifier may consult
+ * @param request The report being verified
+ * @returns The verdict, with its transcript
+ */
+export declare function verifyOffense(ctx: OffenseVerificationContext, request: SlashRequest): Promise<OffenseVerdict>;
+//# sourceMappingURL=verifyOffense.d.ts.map

package/dist/node/modules/slashing/verify/verifyOffense.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyOffense.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/verifyOffense.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAErE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACpE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wCAAwC,CAAA;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAWrE;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAQ5E,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,0BAA0B,EAC/B,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,cAAc,CAAC,CAwBzB"}

package/dist/node/modules/slashing/verify/verifyRewardOvermint.d.ts

@@ -0,0 +1,23 @@
+import type { OffenseProcedure } from '../model/OffenseProcedure.js';
+/**
+ * O3 — reward overmint: paying yourself more than the rules allowed.
+ *
+ * The allowance is recomputed from the register rather than read from the block, since a block
+ * that could state its own allowance could authorise anything. Where the allowance comes from
+ * depends on how the chain is configured — a fixed schedule, or the staking contract — and when
+ * it comes from the contract it is read at the parent's anchor rather than at a live head, so
+ * every verifier asks the contract the same question.
+ *
+ * Minting is counted only from the zero address. A producer moving its own balance around is
+ * spending money that already existed, which is nobody's business but its own.
+ *
+ * Under-minting is not an offense here. A producer that pays itself less than it could has taken
+ * nothing from anyone, and treating generosity as misconduct would be absurd.
+ *
+ * Only the zero-address mint clause is implemented. The specification's fee-rule and step-transfer
+ * clauses wait on the deterministic fee replay and the step-boundary reader; until they land,
+ * reports alleging those shapes resolve on the mint clause alone — never as a conviction the
+ * missing clauses would have had to establish.
+ */
+export declare const verifyRewardOvermint: OffenseProcedure;
+//# sourceMappingURL=verifyRewardOvermint.d.ts.map

package/dist/node/modules/slashing/verify/verifyRewardOvermint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyRewardOvermint.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/verify/verifyRewardOvermint.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AA6BpE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,EAAE,gBAuClC,CAAA"}

package/dist/node/modules/validation/elevatedPayload/lib/findElevatingTransaction.d.ts

@@ -0,0 +1,14 @@
+import type { Payload, WithHashMeta } from '@xyo-network/sdk';
+import type { HydratedBlockWithHashMeta, TransactionBoundWitnessWithHashMeta } from '@xyo-network/xl1-sdk';
+/**
+ * The transaction in this block that elevated the payload, when one did.
+ *
+ * A payload can also ride directly in the block, elevated by the block signer rather than by a
+ * transaction. Callers that need a signer to bind against must be able to tell the two apart,
+ * because those two paths attribute the payload to entirely different addresses.
+ * @param payload The payload being validated
+ * @param block The hydrated block carrying it
+ * @returns The elevating transaction, or undefined when the payload rode directly
+ */
+export declare function findElevatingTransaction(payload: WithHashMeta<Payload>, [, payloads]: HydratedBlockWithHashMeta): TransactionBoundWitnessWithHashMeta | undefined;
+//# sourceMappingURL=findElevatingTransaction.d.ts.map

package/dist/node/modules/validation/elevatedPayload/lib/findElevatingTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findElevatingTransaction.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/lib/findElevatingTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,KAAK,EAAE,yBAAyB,EAAE,mCAAmC,EAAE,MAAM,sBAAsB,CAAA;AAG1G;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAC9B,CAAC,EAAE,QAAQ,CAAC,EAAE,yBAAyB,GACtC,mCAAmC,GAAG,SAAS,CAIjD"}

package/dist/node/modules/validation/elevatedPayload/lib/index.d.ts

@@ -1,7 +1,9 @@
+export * from './findElevatingTransaction.js';
 export * from './isElevatedFromBlock.js';
 export * from './validateElevatedFromBlock.js';
 export * from './validateElevatedFromTransaction.js';
 export * from './validateIncludedInBlock.js';
+export * from './validateSlashPayloadInBlock.js';
 export * from './validateTransactionInBlock.js';
 export * from './validateTypedPayloadInBlock.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/node/modules/validation/elevatedPayload/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,sCAAsC,CAAA;AACpD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,0BAA0B,CAAA;AACxC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,sCAAsC,CAAA;AACpD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA"}

package/dist/node/modules/validation/elevatedPayload/lib/validateSlashPayloadInBlock.d.ts

@@ -0,0 +1,33 @@
+import type { IdentityFunction } from '@ariestools/sdk';
+import type { Payload, XyoAddress } from '@xyo-network/sdk';
+import type { HydratedBlockWithHashMeta, InBlockPayloadValidationFunctionContext, InBlockRuleParams, TransactionBoundWitnessWithHashMeta } from '@xyo-network/xl1-sdk';
+/** What the shared slash-payload checks concluded, plus the rules the caller still needs. */
+export interface SlashPayloadGateResult {
+    /** Reasons the payload is not admissible; empty when the shared checks passed. */
+    errors: Error[];
+    /** The rules in force at the carrying height, when they resolved. */
+    params?: InBlockRuleParams;
+    /** The transaction that elevated the payload, once binding has confirmed it. */
+    transaction?: TransactionBoundWitnessWithHashMeta;
+}
+/**
+ * The checks every slash payload shares: the activation gate, then signer binding.
+ *
+ * Every slash payload is transaction-elevation-only. A payload riding directly in the block would
+ * bind to the block signer instead of a transaction sender, and nothing in the design says what
+ * that would mean — so that path is refused rather than guessed at. Binding `from` to the
+ * elevating transaction's sender gets self-signing discipline transitively, since the transaction
+ * validator has already tied `tx.from` to a verified bound-witness signer.
+ *
+ * The resolved rules come back so a caller can ask its own questions of them without resolving
+ * the register a second time, and so the gate stays the only place that decides admissibility.
+ * @param context The validation context, which may carry no register at all
+ * @param payload The payload being validated
+ * @param block The hydrated block carrying it
+ * @param identityFunction Guard establishing the payload is the type expected
+ * @param fromOf Reads the address the payload claims to be from
+ * @param subject What is being gated, named for the error message
+ * @returns The shared verdict and the rules in force
+ */
+export declare function validateSlashPayloadInBlock<T extends Payload>(context: InBlockPayloadValidationFunctionContext, payload: Payload, block: HydratedBlockWithHashMeta, identityFunction: IdentityFunction<T>, fromOf: (payload: T) => XyoAddress, subject: string): Promise<SlashPayloadGateResult>;
+//# sourceMappingURL=validateSlashPayloadInBlock.d.ts.map

package/dist/node/modules/validation/elevatedPayload/lib/validateSlashPayloadInBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSlashPayloadInBlock.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/lib/validateSlashPayloadInBlock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE3D,OAAO,KAAK,EACV,yBAAyB,EAAE,uCAAuC,EAAE,iBAAiB,EACrF,mCAAmC,EACpC,MAAM,sBAAsB,CAAA;AAK7B,6FAA6F;AAC7F,MAAM,WAAW,sBAAsB;IACrC,kFAAkF;IAClF,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,qEAAqE;IACrE,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,gFAAgF;IAChF,WAAW,CAAC,EAAE,mCAAmC,CAAA;CAClD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,2BAA2B,CAAC,CAAC,SAAS,OAAO,EACjE,OAAO,EAAE,uCAAuC,EAChD,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,yBAAyB,EAChC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC,CAAC,EACrC,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,UAAU,EAClC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,sBAAsB,CAAC,CAqBjC"}

package/dist/node/modules/validation/elevatedPayload/payloads/index.d.ts

@@ -4,6 +4,11 @@ export * from './validateBridgeSourceObservationInBlock.js';
 export * from './validateChainStakeIntentInBlock.js';
 export * from './validateHashInBlock.js';
 export * from './validateSchemaInBlock.js';
+export * from './validateSlashAdjudicationInBlock.js';
+export * from './validateSlashChallengeInBlock.js';
+export * from './validateSlashCommitInBlock.js';
+export * from './validateSlashEvidenceInBlock.js';
+export * from './validateSlashRequestInBlock.js';
 export * from './validateTimeInBlock.js';
 export * from './validateTransferInBlock.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/node/modules/validation/elevatedPayload/payloads/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/payloads/index.ts"],"names":[],"mappings":"AAAA,cAAc,kDAAkD,CAAA;AAChE,cAAc,kCAAkC,CAAA;AAChD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,sCAAsC,CAAA;AACpD,cAAc,0BAA0B,CAAA;AACxC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,8BAA8B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/payloads/index.ts"],"names":[],"mappings":"AAAA,cAAc,kDAAkD,CAAA;AAChE,cAAc,kCAAkC,CAAA;AAChD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,sCAAsC,CAAA;AACpD,cAAc,0BAA0B,CAAA;AACxC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,uCAAuC,CAAA;AACrD,cAAc,oCAAoC,CAAA;AAClD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,mCAAmC,CAAA;AACjD,cAAc,kCAAkC,CAAA;AAChD,cAAc,0BAA0B,CAAA;AACxC,cAAc,8BAA8B,CAAA"}