@xyo-network/chain-sdk 5.0.4 → 5.1.0

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

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashAdjudicationInBlock.d.ts

@@ -0,0 +1,14 @@
+import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk';
+/**
+ * Validates a slash adjudication carried in a block.
+ *
+ * Only the arbiter named by the register may close a report, and that binding survives well past
+ * the point where reporting itself opens up — an adjudication from anyone else is not a minority
+ * opinion, it is a forged verdict.
+ *
+ * Whether a confirmed adjudication names its claimant is an arbiter duty checked when the
+ * adjudication is recomputed, not a question of block validity. A block carrying a sloppy but
+ * genuine verdict is still a valid block.
+ */
+export declare const validateSlashAdjudicationInBlock: InBlockPayloadValidationFunction;
+//# sourceMappingURL=validateSlashAdjudicationInBlock.d.ts.map

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashAdjudicationInBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSlashAdjudicationInBlock.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/payloads/validateSlashAdjudicationInBlock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAA;AAK5E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gCAAgC,EAAE,gCAyB9C,CAAA"}

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashChallengeInBlock.d.ts

@@ -0,0 +1,10 @@
+import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk';
+/**
+ * Validates a slash challenge carried in a block.
+ *
+ * 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 here to deter.
+ */
+export declare const validateSlashChallengeInBlock: InBlockPayloadValidationFunction;
+//# sourceMappingURL=validateSlashChallengeInBlock.d.ts.map

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashChallengeInBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSlashChallengeInBlock.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/payloads/validateSlashChallengeInBlock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAA;AAK5E;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,EAAE,gCAqB3C,CAAA"}

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashCommitInBlock.d.ts

@@ -0,0 +1,10 @@
+import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk';
+/**
+ * Validates a slash commitment carried in a block.
+ *
+ * A commitment reserves a report before its evidence is public, which is what stops a reporter's
+ * work from being lifted from the mempool and re-filed under someone else's name. The commitment
+ * itself is opaque here by design — checking what it hides is the reveal's job.
+ */
+export declare const validateSlashCommitInBlock: InBlockPayloadValidationFunction;
+//# sourceMappingURL=validateSlashCommitInBlock.d.ts.map

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashCommitInBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSlashCommitInBlock.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/payloads/validateSlashCommitInBlock.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gCAAgC,EAEjC,MAAM,sBAAsB,CAAA;AAsC7B;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,gCAwCxC,CAAA"}

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashEvidenceInBlock.d.ts

@@ -0,0 +1,10 @@
+import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk';
+/**
+ * Validates a slash evidence carried in a block.
+ *
+ * A container carries artifacts and asserts nothing about them, so past the activation gate and
+ * signer binding there is nothing left to check. No size ceiling is imposed: character storage is
+ * already priced by gas, so an oversized container costs its sender what it costs the chain.
+ */
+export declare const validateSlashEvidenceInBlock: InBlockPayloadValidationFunction;
+//# sourceMappingURL=validateSlashEvidenceInBlock.d.ts.map

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashEvidenceInBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSlashEvidenceInBlock.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/payloads/validateSlashEvidenceInBlock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAA;AAK5E;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,EAAE,gCAqB1C,CAAA"}

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashRequestInBlock.d.ts

@@ -0,0 +1,14 @@
+import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk';
+/**
+ * Validates a slash request carried in a block.
+ *
+ * A request is a recordable transaction, not a verdict, so this checks that it is well-formed and
+ * that its evidence exists — never whether the accusation is true. An unverifiable request is
+ * still a valid request; deciding it is the arbiter's job.
+ *
+ * The reportable gate is asked of the height the offense happened at, not the height the report
+ * lands at. Comparing against the carrying height would make a rule retroactive and turn conduct
+ * that was legal when it occurred into an offense.
+ */
+export declare const validateSlashRequestInBlock: InBlockPayloadValidationFunction;
+//# sourceMappingURL=validateSlashRequestInBlock.d.ts.map

package/dist/neutral/modules/validation/elevatedPayload/payloads/validateSlashRequestInBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSlashRequestInBlock.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/validation/elevatedPayload/payloads/validateSlashRequestInBlock.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gCAAgC,EAEjC,MAAM,sBAAsB,CAAA;AA8D7B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,EAAE,gCAqCzC,CAAA"}

package/dist/neutral/modules/validation/elevatedPayload/validatePayloadInBlock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePayloadInBlock.d.ts","sourceRoot":"","sources":["../../../../../src/modules/validation/elevatedPayload/validatePayloadInBlock.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAA;AAwB5E,eAAO,MAAM,sBAAsB,EAAE,gCAwBpC,CAAA"}
+{"version":3,"file":"validatePayloadInBlock.d.ts","sourceRoot":"","sources":["../../../../../src/modules/validation/elevatedPayload/validatePayloadInBlock.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAA;AAiC5E,eAAO,MAAM,sBAAsB,EAAE,gCAwBpC,CAAA"}

package/dist/neutral/protocol.mjs

@@ -71,6 +71,9 @@ var isBuildNextBlockOptions = (value) => {
 function calculateCompletedStepReward(step, balance) {
   return AttoXL1(StepRewardFractions[step][0] * balance / StepRewardFractions[step][1]);
 }
+function supersedesField(options) {
+  return isBuildNextBlockOptions(options) && options.supersedes !== void 0 ? { supersedes: options.supersedes } : {};
+}
 async function buildBlock(options) {
   const previousBlockNumber = isBuildGenesisBlockOptions(options) ? -1 : options.previousBlockNumber;
   const blockNumber = asXL1BlockNumber(previousBlockNumber + 1, true);
@@ -127,7 +130,8 @@ async function buildBlock(options) {
     chain: chainId,
     previous,
     step_hashes,
-    protocol
+    protocol,
+    ...supersedesField(options)
   }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder.addStorageMeta(payloads)).build();
   assertEx(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
   return [await PayloadBuilder.addStorageMeta(bw), txPayloads];
@@ -152,7 +156,7 @@ import {
   AttoXL1 as AttoXL12,
   XYO_STEP_REWARD_ADDRESS as XYO_STEP_REWARD_ADDRESS2
 } from "@xyo-network/xl1-sdk";
-async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS2, stepRewardPoolBalance = AttoXL12(0n), protocol, chainId) {
+async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS2, stepRewardPoolBalance = AttoXL12(0n), protocol, chainId, supersedes) {
   return await buildBlock({
     chainId: chainId ?? previousBlock.chain,
     previousBlockNumber: previousBlock.block,
@@ -163,7 +167,8 @@ async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainS
     signers,
     protocol,
     chainStepRewardAddress,
-    stepRewardPoolBalance
+    stepRewardPoolBalance,
+    supersedes
   });
 }