@xyo-network/chain-sdk 5.0.3 → 5.1.0

package/dist/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/slashing.d.ts

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

package/dist/browser/slashing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashing.d.ts","sourceRoot":"","sources":["../../src/slashing.ts"],"names":[],"mappings":"AACA,cAAc,WAAW,CAAA"}

package/dist/neutral/analyze.mjs

@@ -1,3 +1,14 @@
+// src/modules/analyze/admission.ts
+var AdmissionModes = ["allowlist", "shadow", "enforce"];
+var AdmissionShadowPublishRunnerMoniker = "AdmissionShadowPublishRunner";
+function isAdmissionShadowPublishRunner(value) {
+  return typeof value?.publish === "function";
+}
+function isDivergent(assessment) {
+  if (!assessment.eligibility.resolvable) return false;
+  return assessment.admittedByAllowList !== (assessment.eligibility.eligible === true);
+}
+
 // src/modules/analyze/analyzeChain.ts
 import {
   assertEx,
@@ -165,12 +176,14 @@ import {
   getWindowedChain
 } from "@xyo-network/xl1-sdk";
 var ChainHeadSelector = class extends ChainFinalizer {
+  admission;
   allowedProducers;
   backoffMs;
   minCandidates;
   _timeSinceLastUncle = Date.now();
   constructor(params) {
     super(params);
+    this.admission = params.admission ?? "allowlist";
     this.allowedProducers = params.allowedProducers;
     this.backoffMs = params.backoffMs;
     this.minCandidates = params.minCandidates;
@@ -184,13 +197,78 @@ var ChainHeadSelector = class extends ChainFinalizer {
   async findBestHead() {
     return await spanRootAsync2("findBestHead", async () => {
       const allProposedBlocks = await this.mempoolViewer.pendingBlocks();
-      const allowedProducers = this.allowedProducers;
-      const proposedBlocks = isDefined2(allowedProducers) && allowedProducers.length > 0 ? allProposedBlocks.filter((pb) => allowedProducers.includes(toAddress2(pb[0].addresses[0]))) : allProposedBlocks;
+      const allowed = allProposedBlocks.filter((pb) => this.isAllowed(pb));
+      const proposedBlocks = await this.admit(allProposedBlocks, allowed);
       this.windowedFinalizedChain = await getWindowedChain(this.context, this.blockViewer, this.maxWindowSize, this.windowedFinalizedChain);
       const uncles = findUncles(this.context, this.windowedFinalizedChain, proposedBlocks);
       return findBestUncle(this.windowedFinalizedChain, uncles, { backoffMs: this.backoffMs, minCandidates: this.minCandidates }) ?? this.windowedFinalizedChain;
     }, this.context);
   }
+  /**
+   * Applies the configured admission posture.
+   *
+   * In `shadow` the allow-list still decides — participation is computed and published beside it,
+   * and changes nothing. That is the entire value of the posture: the network keeps behaving
+   * exactly as it did while everyone gets to see what the new rule would have done.
+   *
+   * In `enforce` participation gates, but only when it reached a conclusion. A candidate whose
+   * standing cannot be established is admitted, not rejected — otherwise a finalizer that lost
+   * its stake reader would quietly stop accepting anyone's blocks and stall the chain.
+   *
+   * Assessments publish in both postures. The audit trail must not disappear at the moment
+   * admission starts gating — enforce is when it matters most.
+   */
+  async admit(all, allowed) {
+    if (this.admission === "allowlist" || this.params.eligibility === void 0) return allowed;
+    const assessments = await this.assess(all);
+    await this.publishShadow(assessments);
+    if (this.admission === "shadow") return allowed;
+    const ineligible = new Set(assessments.filter((assessment) => assessment.eligibility.resolvable && assessment.eligibility.eligible !== true).map((assessment) => assessment.dataHash));
+    return allowed.filter((candidate) => !ineligible.has(candidate[0]._dataHash));
+  }
+  /**
+   * Runs both gates over every candidate.
+   *
+   * An evaluator that throws yields an unresolvable assessment rather than an exception: this
+   * sits on the head-selection path, and a flaky stake reader must never be able to stop the
+   * chain from finalizing.
+   */
+  async assess(all) {
+    const evaluate = this.params.eligibility;
+    if (evaluate === void 0) return [];
+    const evaluateSafely = async (candidate) => {
+      try {
+        return await evaluate(candidate);
+      } catch {
+        return { resolvable: false };
+      }
+    };
+    return await Promise.all(all.map(async (candidate) => ({
+      admittedByAllowList: this.isAllowed(candidate),
+      block: candidate[0].block,
+      dataHash: candidate[0]._dataHash,
+      eligibility: await evaluateSafely(candidate),
+      producer: candidate[0].addresses[0]
+    })));
+  }
+  /** Whether the configured allow-list admits a candidate. An empty list admits everyone. */
+  isAllowed(candidate) {
+    const allowedProducers = this.allowedProducers;
+    return isDefined2(allowedProducers) && allowedProducers.length > 0 ? allowedProducers.includes(toAddress2(candidate[0].addresses[0])) : true;
+  }
+  /** Publishes what the two gates concluded, swallowing failures. */
+  async publishShadow(assessments) {
+    const publish = this.params.publishAdmissionShadow;
+    if (publish === void 0 || assessments.length === 0) return;
+    try {
+      await publish({
+        assessments,
+        divergent: assessments.filter((assessment) => isDivergent(assessment)),
+        head: this.windowedFinalizedChain[0]?.[0]?.block ?? 0
+      });
+    } catch {
+    }
+  }
 };
 
 // src/modules/analyze/producer/ChainProducersAnalyzer.ts
@@ -364,6 +442,8 @@ var TransferAnalyzer = class {
   }
 };
 export {
+  AdmissionModes,
+  AdmissionShadowPublishRunnerMoniker,
   BalanceAnalyzer,
   ChainFinalizer,
   ChainHeadSelector,
@@ -375,9 +455,11 @@ export {
   ChainSummaryTransfersSchema,
   TransferAnalyzer,
   analyzeChain,
+  isAdmissionShadowPublishRunner,
   isChainSummaryBalances,
   isChainSummaryProducers,
   isChainSummaryStakeIntent,
-  isChainSummaryTransfers
+  isChainSummaryTransfers,
+  isDivergent
 };
 //# sourceMappingURL=analyze.mjs.map