@xyo-network/chain-sdk 5.0.4 → 5.1.1

package/dist/neutral/modules/slashing/detect/DetectedOffense.d.ts

@@ -0,0 +1,27 @@
+import type { Payload } from '@xyo-network/sdk';
+import type { OffenseCode } from '@xyo-network/xl1-sdk';
+import type { OffenseKey } from '../model/offenseKey.js';
+import type { OffenseVerdict } from '../model/VerificationOutcome.js';
+/**
+ * Conduct a watcher found and then verified.
+ *
+ * Carries the verdict rather than a bare flag, because the transcript is what makes the detection
+ * worth anything: it is the same record an arbiter would publish, so an operator watching in
+ * telemetry mode can see exactly what a report would have said before any are ever filed.
+ */
+export interface DetectedOffense {
+    /**
+     * The artifacts the verdict rests on.
+     *
+     * Carried because a report has to supply them: a reporter that named hashes without producing
+     * the objects would be asking everyone else to take its word for it.
+     */
+    artifacts: Payload[];
+    /** What the offense is filed under. */
+    key: OffenseKey;
+    /** Which class. */
+    offense: OffenseCode;
+    /** What verification concluded, with its transcript. */
+    verdict: OffenseVerdict;
+}
+//# sourceMappingURL=DetectedOffense.d.ts.map

package/dist/neutral/modules/slashing/detect/DetectedOffense.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DetectedOffense.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/detect/DetectedOffense.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAEvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAErE;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,SAAS,EAAE,OAAO,EAAE,CAAA;IACpB,uCAAuC;IACvC,GAAG,EAAE,UAAU,CAAA;IACf,mBAAmB;IACnB,OAAO,EAAE,WAAW,CAAA;IACpB,wDAAwD;IACxD,OAAO,EAAE,cAAc,CAAA;CACxB"}

package/dist/neutral/modules/slashing/detect/candidatePairs.d.ts

@@ -0,0 +1,44 @@
+import type { Hash } from '@ariestools/sdk';
+import type { XyoAddress } from '@xyo-network/sdk';
+/** One candidate a watcher saw a producer sign, reduced to what deciding equivocation needs. */
+export interface CandidateSighting {
+    /** Height the candidate claims. */
+    block: number;
+    /** Recomputed signed identity — never the storage hash, which client meta can move. */
+    dataHash: Hash;
+    /** Parent the candidate builds on. */
+    previous: Hash | null;
+    /** Address that signed it. */
+    producer: XyoAddress;
+    /** The candidate this one declares it replaces, when it declares one. */
+    supersedes?: Hash;
+}
+/** Two candidates from one producer that compete for the same slot. */
+export interface CandidatePair {
+    /** Height they compete at. */
+    block: number;
+    /** The earlier sighting. */
+    first: CandidateSighting;
+    /** Who signed both. */
+    producer: XyoAddress;
+    /** The later sighting. */
+    second: CandidateSighting;
+}
+/**
+ * Finds candidate pairs that look like equivocation among what a watcher has seen.
+ *
+ * This is detection, not judgment. It answers which pairs are worth verifying, and a pair reaching
+ * this list is not yet an accusation — the verification procedure decides that, and it re-derives
+ * everything from the artifacts rather than trusting anything here.
+ *
+ * A declared link clears the pair immediately, so an honest producer's re-proposal never enters
+ * the pipeline at all. Doing that here rather than later matters: a watcher that queued every
+ * re-proposal for verification would spend its budget on producers doing exactly what they should.
+ *
+ * Sightings are compared by recomputed identity, so a candidate seen twice through different paths
+ * collapses to one rather than becoming a pair with itself.
+ * @param sightings Candidates the watcher has observed
+ * @returns Pairs worth verifying, one per competing combination
+ */
+export declare function findCandidatePairs(sightings: readonly CandidateSighting[]): CandidatePair[];
+//# sourceMappingURL=candidatePairs.d.ts.map

package/dist/neutral/modules/slashing/detect/candidatePairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidatePairs.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/detect/candidatePairs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,gGAAgG;AAChG,MAAM,WAAW,iBAAiB;IAChC,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,uFAAuF;IACvF,QAAQ,EAAE,IAAI,CAAA;IACd,sCAAsC;IACtC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAA;IACrB,8BAA8B;IAC9B,QAAQ,EAAE,UAAU,CAAA;IACpB,yEAAyE;IACzE,UAAU,CAAC,EAAE,IAAI,CAAA;CAClB;AAED,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,4BAA4B;IAC5B,KAAK,EAAE,iBAAiB,CAAA;IACxB,uBAAuB;IACvB,QAAQ,EAAE,UAAU,CAAA;IACpB,0BAA0B;IAC1B,MAAM,EAAE,iBAAiB,CAAA;CAC1B;AAaD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,iBAAiB,EAAE,GAAG,aAAa,EAAE,CAqB3F"}

package/dist/neutral/modules/slashing/detect/index.d.ts

@@ -0,0 +1,5 @@
+export * from './candidatePairs.js';
+export * from './DetectedOffense.js';
+export * from './offenseGate.js';
+export * from './suppression.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/slashing/detect/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/detect/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA"}

package/dist/neutral/modules/slashing/detect/offenseGate.d.ts

@@ -0,0 +1,18 @@
+import type { ChainParams, OffenseCode } from '@xyo-network/xl1-sdk';
+/**
+ * Whether a watcher may treat conduct at a height as a reportable offense.
+ *
+ * Two gates, and the second one only applies to equivocation. A producer cannot declare that one
+ * candidate replaces another until the field that says so is active, so before that activation
+ * every honest re-proposal is indistinguishable from equivocation. Reporting the class then would
+ * accuse operators of an offense the protocol gave them no way to avoid.
+ *
+ * That conjunction is fixed here rather than left to configuration. An operator who could switch
+ * it off would be arming their node to file accusations the chain cannot sustain.
+ * @param params The register version covering the offense height
+ * @param offense The offense class being considered
+ * @param height The XL1 height the conduct occurred at
+ * @returns True when reports naming this class at this height may be recorded
+ */
+export declare function isOffenseWatchable(params: ChainParams, offense: OffenseCode, height: number): boolean;
+//# sourceMappingURL=offenseGate.d.ts.map

package/dist/neutral/modules/slashing/detect/offenseGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offenseGate.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/detect/offenseGate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAGpE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAGrG"}

package/dist/neutral/modules/slashing/detect/suppression.d.ts

@@ -0,0 +1,23 @@
+import type { OffenseKey } from '../model/offenseKey.js';
+import type { SlashHistoryReader } from '../model/SlashHistoryReader.js';
+/** Why a watcher should not file a report it would otherwise have filed. */
+export type SuppressionReason = 'adjudicated' | 'already-reported';
+/**
+ * Whether an offense a watcher has detected is already spoken for.
+ *
+ * Duplicate detection is normal — every validator watching the same chain sees the same
+ * misconduct — so the interesting question is not whether to detect it but whether to add another
+ * report of it.
+ *
+ * A settled offense is the stronger case. Filing against something already adjudicated is not
+ * merely redundant: an adjudicated offense cannot be re-litigated, so the new report is itself
+ * invalid and exposes its filer to a counter-slash. A watcher must never walk into that.
+ *
+ * An existing unsettled report is only redundant. Nothing is lost by staying quiet — the offense
+ * is already on the record and the bounty already claimed by whoever got there first.
+ * @param history Finalized slash traffic as this watcher can see it
+ * @param key The offense being considered
+ * @returns Why to stay quiet, or undefined when the report is worth filing
+ */
+export declare function suppressionFor(history: SlashHistoryReader, key: OffenseKey): Promise<SuppressionReason | undefined>;
+//# sourceMappingURL=suppression.d.ts.map

package/dist/neutral/modules/slashing/detect/suppression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suppression.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/detect/suppression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAExE,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,kBAAkB,CAAA;AAElE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,kBAAkB,EAC3B,GAAG,EAAE,UAAU,GACd,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAGxC"}

package/dist/neutral/modules/slashing/eligibility/evaluateProducerEligibility.d.ts

@@ -0,0 +1,71 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { XyoAddress } from '@xyo-network/sdk';
+import type { ChainParams, StakeSnapshotViewerMethods } from '@xyo-network/xl1-sdk';
+/**
+ * Whether an address has a current declaration to produce, as of a height.
+ *
+ * `undefined` means the question could not be answered — no intent reader is wired — which is
+ * different from `false` (the reader looked and found nothing current). Collapsing the two would
+ * turn a missing reader into either a free pass or an accusation, depending on the direction.
+ */
+export type HasValidIntent = (address: XyoAddress, height: number) => Promisable<boolean | undefined>;
+/** What the participation predicate needs about a candidate block. */
+export interface EligibilityInput {
+    /** The producer being evaluated. */
+    accused: XyoAddress;
+    /** EVM anchor carried by the candidate itself. */
+    blockAnchor?: number;
+    /** The candidate's XL1 height, where intent windows are judged. */
+    height: number;
+    /** Whether the address has a current production declaration. */
+    intent: HasValidIntent;
+    /** The register version in force. */
+    params: ChainParams;
+    /** EVM anchor carried by the candidate's parent. */
+    parentAnchor?: number;
+    /** Stake as it stood at an EVM height. */
+    snapshot?: StakeSnapshotViewerMethods;
+}
+/** What evaluating participation concluded, including the numbers it concluded it from. */
+export interface EligibilityEvaluation {
+    /** Seasoned active stake measured at the evaluation point. */
+    activeStake?: bigint;
+    /** The EVM height stake was measured at. */
+    eStar?: number;
+    /** Whether the address may produce, when that could be established. */
+    eligible?: boolean;
+    /** Whether the address has a current declaration. */
+    intentValid?: boolean;
+    /** Why not, when it is not. */
+    reason?: string;
+    /** False when the inputs to the predicate could not be resolved at all. */
+    resolvable: boolean;
+    /** The seasoned portion staked on itself. */
+    selfBond?: bigint;
+}
+/**
+ * The one place participation is decided.
+ *
+ * Admission and after-the-fact verification call this same function, and that is the point. If
+ * the finalizer's idea of who may produce and the offense procedure's idea ever diverged, a block
+ * could be admitted by the network and simultaneously constitute an offense by its producer — so
+ * there is exactly one implementation and both callers take it.
+ *
+ * The measurement point comes from the two blocks' own signed anchors rather than any live view,
+ * so the answer does not depend on when it is asked. A block admissible when it was produced must
+ * still evaluate as admissible a week later.
+ *
+ * Stake is counted seasoned: a position participates only once it has sat at risk for the
+ * register's minimum age, so production rights cannot be flash-acquired the block before the
+ * measurement point. The unaged total is measured beside it purely so the report can tell an
+ * entrant waiting out seasoning apart from an operator short of capital.
+ *
+ * The tri-state matters as much as the verdict. `resolvable: false` means the question could not
+ * be put — no snapshot, no anchors, no intent reader — which admission treats as "do not gate"
+ * and verification treats as inconclusive. Collapsing it into ineligible would turn a missing
+ * reader into an accusation.
+ * @param input The candidate, the register, and the readers to consult
+ * @returns The verdict with the measurements behind it
+ */
+export declare function evaluateProducerEligibility(input: EligibilityInput): Promise<EligibilityEvaluation>;
+//# sourceMappingURL=evaluateProducerEligibility.d.ts.map

package/dist/neutral/modules/slashing/eligibility/evaluateProducerEligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluateProducerEligibility.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/eligibility/evaluateProducerEligibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAA;AAGnF;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,GAAG,SAAS,CAAC,CAAA;AAErG,sEAAsE;AACtE,MAAM,WAAW,gBAAgB;IAC/B,oCAAoC;IACpC,OAAO,EAAE,UAAU,CAAA;IACnB,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAA;IACd,gEAAgE;IAChE,MAAM,EAAE,cAAc,CAAA;IACtB,qCAAqC;IACrC,MAAM,EAAE,WAAW,CAAA;IACnB,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,0BAA0B,CAAA;CACtC;AAED,2FAA2F;AAC3F,MAAM,WAAW,qBAAqB;IACpC,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,qDAAqD;IACrD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,+BAA+B;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,2EAA2E;IAC3E,UAAU,EAAE,OAAO,CAAA;IACnB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,2BAA2B,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA6CzG"}

package/dist/neutral/modules/slashing/eligibility/index.d.ts

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

package/dist/neutral/modules/slashing/eligibility/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/eligibility/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAA"}

package/dist/neutral/modules/slashing/index/SlashIndexStore.d.ts

@@ -0,0 +1,22 @@
+import type { JsonObject, Promisable } from '@ariestools/sdk';
+/** Moniker the slash index's store resolves under. */
+export declare const SlashIndexStoreMoniker = "SlashIndexStore";
+/**
+ * The object store the slash index is written to.
+ *
+ * Named apart from any S3 base class on purpose: the pass that decides *what* to write is pure
+ * and tested on its own, and this is the whole of what it needs from the world. Keeping the two
+ * separate is what makes the crash-safety argument checkable — the part with the reasoning has no
+ * I/O, and the part with I/O has no reasoning.
+ */
+export interface SlashIndexStore {
+    /** Whether an object already exists, so immutable writes can be skipped. */
+    hasObject(path: string): Promisable<boolean>;
+    /** Reads a published object, or undefined when it is not there. */
+    readObject(path: string): Promisable<unknown>;
+    /** Writes an object. */
+    writeObject(path: string, value: JsonObject, immutable: boolean): Promisable<void>;
+}
+/** Whether a resolved provider can actually serve as the index store. */
+export declare function isSlashIndexStore(value: unknown): value is SlashIndexStore;
+//# sourceMappingURL=SlashIndexStore.d.ts.map

package/dist/neutral/modules/slashing/index/SlashIndexStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlashIndexStore.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/index/SlashIndexStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE7D,sDAAsD;AACtD,eAAO,MAAM,sBAAsB,oBAAoB,CAAA;AAEvD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IAC5C,mEAAmE;IACnE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IAC7C,wBAAwB;IACxB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,CAAA;CACnF;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAK1E"}

package/dist/neutral/modules/slashing/index/foldSlashIndex.d.ts

@@ -0,0 +1,56 @@
+import type { Hash, JsonObject } from '@ariestools/sdk';
+import type { SignedHydratedBlockWithHashMeta, SlashIndexKeyRecord } from '@xyo-network/xl1-sdk';
+/** One object to write, and whether it may ever be rewritten. */
+export interface SlashIndexWrite {
+    /** True when the object is content-addressed and must never change once written. */
+    immutable: boolean;
+    /** Where it goes. */
+    path: string;
+    /** What goes there. */
+    value: JsonObject;
+}
+/** Everything one batch of finalized blocks contributes to the index. */
+export interface SlashIndexDelta {
+    /** Producer aggregates: path to the offense keys seen for that producer. */
+    accused: Map<string, string[]>;
+    /** Per-offense aggregates, keyed by their path. */
+    keys: Map<string, SlashIndexKeyRecord>;
+    /**
+     * Adjudications and challenges whose report was not in this batch.
+     *
+     * Their offense cannot be resolved from the blocks alone — the report that names it is further
+     * back — so the writing pass resolves them against the published request records.
+     */
+    pending: {
+        hash: Hash;
+        kind: 'adjudication' | 'challenge';
+        request: Hash;
+    }[];
+    /** Content-addressed records, safe to skip when already present. */
+    records: SlashIndexWrite[];
+}
+/**
+ * Folds finalized blocks into everything the index should gain from them.
+ *
+ * Pure, and deliberately so: the pass that writes has to be safe to re-run after a crash, and the
+ * cheapest way to be sure of that is for the decision of *what* to write to depend on nothing but
+ * the blocks. Run it twice over the same range and it produces the same delta.
+ *
+ * Aggregates are keyed by canonical offense identity, so several validators reporting the same
+ * misconduct converge on one record instead of accumulating as separate accusations.
+ * @param blocks Finalized blocks to fold, in ascending height order
+ * @returns The records and aggregate contributions from those blocks
+ */
+export declare function foldSlashIndex(blocks: SignedHydratedBlockWithHashMeta[]): SlashIndexDelta;
+/**
+ * Merges an aggregate contribution into whatever is already published.
+ *
+ * Every field either appends or is set once. That is what lets a crashed pass simply rescan: a
+ * second fold over the same blocks adds nothing it did not already add, and a fold over new blocks
+ * never erases what an earlier one recorded.
+ * @param existing The published aggregate, when there is one
+ * @param next The contribution from this pass
+ * @returns The aggregate to publish
+ */
+export declare function mergeKeyRecord(existing: SlashIndexKeyRecord | undefined, next: SlashIndexKeyRecord): SlashIndexKeyRecord;
+//# sourceMappingURL=foldSlashIndex.d.ts.map

package/dist/neutral/modules/slashing/index/foldSlashIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foldSlashIndex.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/index/foldSlashIndex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEvD,OAAO,KAAK,EAAE,+BAA+B,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAShG,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC9B,oFAAoF;IACpF,SAAS,EAAE,OAAO,CAAA;IAClB,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,uBAAuB;IACvB,KAAK,EAAE,UAAU,CAAA;CAClB;AAED,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC9B,mDAAmD;IACnD,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IACtC;;;;;OAKG;IACH,OAAO,EAAE;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,cAAc,GAAG,WAAW,CAAC;QAAC,OAAO,EAAE,IAAI,CAAA;KAAE,EAAE,CAAA;IAC5E,oEAAoE;IACpE,OAAO,EAAE,eAAe,EAAE,CAAA;CAC3B;AAWD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,+BAA+B,EAAE,GAAG,eAAe,CAOzF;AA+ED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,mBAAmB,GAAG,SAAS,EACzC,IAAI,EAAE,mBAAmB,GACxB,mBAAmB,CAYrB"}

package/dist/neutral/modules/slashing/index/index.d.ts

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

package/dist/neutral/modules/slashing/index/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/index/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA"}

package/dist/neutral/modules/slashing/index.d.ts

@@ -0,0 +1,6 @@
+export * from './detect/index.js';
+export * from './eligibility/index.js';
+export * from './index/index.js';
+export * from './model/index.js';
+export * from './verify/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/slashing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/slashing/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA"}

package/dist/neutral/modules/slashing/model/OffenseProcedure.d.ts

@@ -0,0 +1,28 @@
+import type { Hash } from '@ariestools/sdk';
+import type { Payload } from '@xyo-network/sdk';
+import type { SlashRequest } from '@xyo-network/xl1-sdk';
+import type { OffenseVerificationContext } from './OffenseVerificationContext.js';
+import type { OffenseVerdict } from './VerificationOutcome.js';
+/** An artifact that survived re-hashing and signature checking. */
+export interface VerifiedArtifact {
+    /** The recomputed data hash, which is the artifact's identity. */
+    dataHash: Hash;
+    /** The artifact itself. */
+    payload: Payload;
+    /**
+     * The recomputed meta-inclusive hash, when the preamble computed it.
+     *
+     * Signed references — a block's `previous`, a carrier's payload list — may point at either
+     * form, and both are recomputed from the artifact itself so a reference match never rests on
+     * a hash the supplier merely claimed.
+     */
+    storageHash?: Hash;
+}
+/**
+ * One offense class's verification procedure.
+ *
+ * Procedures receive artifacts already re-hashed and signature-checked, so each one reasons about
+ * what the evidence means rather than re-deriving whose it is.
+ */
+export type OffenseProcedure = (ctx: OffenseVerificationContext, request: SlashRequest, artifacts: ReadonlyMap<Hash, VerifiedArtifact>) => Promise<OffenseVerdict>;
+//# sourceMappingURL=OffenseProcedure.d.ts.map

package/dist/neutral/modules/slashing/model/OffenseProcedure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OffenseProcedure.d.ts","sourceRoot":"","sources":["../../../../../src/modules/slashing/model/OffenseProcedure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE9D,mEAAmE;AACnE,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,EAAE,IAAI,CAAA;IACd,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,IAAI,CAAA;CACnB;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,GAAG,EAAE,0BAA0B,EAC/B,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,KAC3C,OAAO,CAAC,cAAc,CAAC,CAAA"}

package/dist/neutral/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/neutral/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/neutral/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/neutral/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/neutral/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/neutral/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/neutral/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/neutral/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/neutral/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/neutral/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/neutral/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/neutral/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"}