@xyo-network/xl1-protocol 5.1.4 → 5.2.1

package/dist/neutral/modules/network-model/staticRest/layout/slashIndex.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+/** Schema id for the slash index head pointer. */
+export declare const SlashIndexHeadSchema: "network.xyo.s3.slash.index.head" & {
+    readonly __schema: true;
+};
+/** Type literal for the slash index head schema. */
+export type SlashIndexHeadSchema = typeof SlashIndexHeadSchema;
+/** Bumped when the index layout changes, so readers can detect a mismatch. */
+export declare const SLASH_INDEX_VERSION = 1;
+/**
+ * Zod schema for the slash index head pointer.
+ *
+ * Written last in every pass. A reader that sees this pointer can rely on everything it names
+ * already being there, which is what makes a crashed pass safe to simply re-run: the pointer only
+ * ever advances over work that finished.
+ */
+export declare const SlashIndexHeadZod: z.ZodObject<{
+    height: z.ZodInt;
+    indexVersion: z.ZodInt;
+    schema: z.ZodLiteral<"network.xyo.s3.slash.index.head" & {
+        readonly __schema: true;
+    }>;
+    anchor: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/** The slash index head pointer. */
+export type SlashIndexHead = z.infer<typeof SlashIndexHeadZod>;
+/** Type guard that checks if a value is a valid SlashIndexHead. */
+export declare const isSlashIndexHead: <T>(value: T) => value is T & {
+    height: number;
+    indexVersion: number;
+    schema: "network.xyo.s3.slash.index.head" & {
+        readonly __schema: true;
+    };
+    anchor?: number | undefined;
+};
+/** Converts a value to SlashIndexHead, throwing if invalid. */
+export declare const asSlashIndexHead: {
+    <T>(value: T): (T & {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    };
+};
+/** Non-validating cast to SlashIndexHead. */
+export declare const toSlashIndexHead: {
+    (value: unknown): {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    };
+};
+/** Schema id for the per-offense aggregate. */
+export declare const SlashIndexKeyRecordSchema: "network.xyo.s3.slash.index.key" & {
+    readonly __schema: true;
+};
+/** Type literal for the per-offense aggregate schema. */
+export type SlashIndexKeyRecordSchema = typeof SlashIndexKeyRecordSchema;
+/**
+ * Zod schema for everything recorded about one offense.
+ *
+ * The aggregates are the only discovery surface, because the published read path cannot list
+ * objects. That is why they are allowed to be rewritten while everything else is immutable — and
+ * why every rewrite only appends, so a pass that runs twice converges instead of losing history.
+ */
+export declare const SlashIndexKeyRecordZod: z.ZodObject<{
+    accused: z.ZodString;
+    adjudication: z.ZodOptional<z.ZodString>;
+    block: z.ZodInt;
+    challenges: z.ZodArray<z.ZodString>;
+    chain: z.ZodString;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        confirmed: "confirmed";
+        refuted: "refuted";
+        indeterminate: "indeterminate";
+        invalid: "invalid";
+    }>>;
+    offense: z.ZodEnum<{
+        equivocation: "equivocation";
+        "invalid-block": "invalid-block";
+        "reward-overmint": "reward-overmint";
+        "false-anchor": "false-anchor";
+        "ineligible-production": "ineligible-production";
+        "invalid-slash-request": "invalid-slash-request";
+        "false-attestation": "false-attestation";
+    }>;
+    requests: z.ZodArray<z.ZodString>;
+    schema: z.ZodLiteral<"network.xyo.s3.slash.index.key" & {
+        readonly __schema: true;
+    }>;
+}, z.core.$strip>;
+/** Everything recorded about one offense. */
+export type SlashIndexKeyRecord = z.infer<typeof SlashIndexKeyRecordZod>;
+/** Type guard that checks if a value is a valid SlashIndexKeyRecord. */
+export declare const isSlashIndexKeyRecord: <T>(value: T) => value is T & {
+    accused: string;
+    block: number;
+    challenges: string[];
+    chain: string;
+    offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+    requests: string[];
+    schema: "network.xyo.s3.slash.index.key" & {
+        readonly __schema: true;
+    };
+    adjudication?: string | undefined;
+    outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+};
+/** Converts a value to SlashIndexKeyRecord, throwing if invalid. */
+export declare const asSlashIndexKeyRecord: {
+    <T>(value: T): (T & {
+        accused: string;
+        block: number;
+        challenges: string[];
+        chain: string;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        requests: string[];
+        schema: "network.xyo.s3.slash.index.key" & {
+            readonly __schema: true;
+        };
+        adjudication?: string | undefined;
+        outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        accused: string;
+        block: number;
+        challenges: string[];
+        chain: string;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        requests: string[];
+        schema: "network.xyo.s3.slash.index.key" & {
+            readonly __schema: true;
+        };
+        adjudication?: string | undefined;
+        outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+    };
+};
+/** Builds a validated slash index head. */
+export declare function createSlashIndexHead(height: number, anchor?: number): SlashIndexHead;
+//# sourceMappingURL=slashIndex.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/slashIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/slashIndex.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,kDAAkD;AAClD,eAAO,MAAM,oBAAoB;;CAAoD,CAAA;AACrF,oDAAoD;AACpD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAIpC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;;iBAQ5B,CAAA;AAEF,oCAAoC;AACpC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,mEAAmE;AACnE,eAAO,MAAM,gBAAgB;;;;;;;CAAkC,CAAA;AAC/D,+DAA+D;AAC/D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAAsD,CAAA;AACnF,6CAA6C;AAC7C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAAsD,CAAA;AAEnF,+CAA+C;AAC/C,eAAO,MAAM,yBAAyB;;CAAmD,CAAA;AACzF,yDAAyD;AACzD,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAA;AAExE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBjC,CAAA;AAEF,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE,wEAAwE;AACxE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;CAAuC,CAAA;AACzE,oEAAoE;AACpE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgE,CAAA;AAElG,2CAA2C;AAC3C,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CAIpF"}

package/dist/neutral/modules/network-model/staticRest/layout/trustedPosture.d.ts

@@ -0,0 +1,81 @@
+import type { ChainId } from '../../../protocol-lib/index.js';
+import type { ChainParams } from './chainParams.js';
+/**
+ * Planning values for the decentralization parameters.
+ *
+ * These are the numbers the papers propose, not values any network is bound to. They are carried
+ * here so a register can be authored without inventing them, and so the one place they live is
+ * the one place a governance change edits.
+ *
+ * The stake amounts are deliberately absent: they are denominated in the staking token's smallest
+ * unit and are a governance decision per network, so a default would be a guess wearing a
+ * default's clothing.
+ */
+export declare const DEFAULT_CHAIN_PARAMS: {
+    attestationRewardBps: number;
+    bountyShareBps: number;
+    burnFloorBps: number;
+    catalogVersion: number;
+    challengeWindowEvmBlocks: number;
+    evidenceFreshnessEvmBlocks: number;
+    evidenceRetentionXl1Blocks: number;
+    executionDelayEvmBlocks: number;
+    freshnessBandEvmBlocks: number;
+    graceBandXl1Blocks: number;
+    maturityEvmBlocks: number;
+    minStakeAgeEvmBlocks: number;
+    opsAllowanceEvmBlocks: number;
+    protocolMin: number;
+    revealDelayEvmBlocks: number;
+    revealDelayXl1Blocks: number;
+    revealWindowEvmBlocks: number;
+    revealWindowXl1Blocks: number;
+    slashFractionsBps: {
+        equivocation: number;
+        'false-anchor': number;
+        'false-attestation': number;
+        'ineligible-production': number;
+        'invalid-block': number;
+        'invalid-slash-request': number;
+        'reward-overmint': number;
+    };
+    slashQuorumCount: number;
+};
+/** What a trusted-posture register needs beyond the planning defaults. */
+export interface TrustedPostureConfig {
+    /** Address whose adjudication records would be honored, once any rule is on. */
+    arbiter: string;
+    /** Absolute bounty ceiling, in the smallest unit. */
+    bountyCapAtto?: string;
+    /** Chain these parameters govern. */
+    chainId: ChainId;
+    /** Minimum producer self-bond, in the smallest unit. */
+    minProducerSelfBondAtto?: string;
+    /** Minimum producer stake, in the smallest unit. */
+    minProducerStakeAtto?: string;
+    /** Minimum validator stake, in the smallest unit. */
+    minValidatorStakeAtto?: string;
+    /** Refundable reporter deposit, in the smallest unit. */
+    reporterDepositAtto?: string;
+    /** Where the allowed block reward comes from. */
+    rewardSource?: 'schedule' | 'contract';
+    /** Version number; the first published register is 1. */
+    version?: number;
+}
+/**
+ * Builds a register describing a network that enforces nothing.
+ *
+ * This is the first version a network publishes, and it changes nothing about how that network
+ * behaves: no rule has an activation height, so every gate reads as inactive and the chain runs
+ * exactly as it did before the register existed. What it does provide is the control plane —
+ * somewhere for a later version to record an activation, and something for nodes to be reading
+ * long before the first rule turns on.
+ *
+ * The stake amounts default to zero because they are meaningless while nothing consumes them. A
+ * network that intends to enforce sets them in the version that first activates admission, when
+ * they have been sized against the value an offense could extract.
+ * @param config Chain identity and any amounts already decided
+ * @returns A register version with no activations
+ */
+export declare function createTrustedPostureParams(config: TrustedPostureConfig): ChainParams;
+//# sourceMappingURL=trustedPosture.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/trustedPosture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trustedPosture.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/trustedPosture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BhC,CAAA;AAED,0EAA0E;AAC1E,MAAM,WAAW,oBAAoB;IACnC,gFAAgF;IAChF,OAAO,EAAE,MAAM,CAAA;IACf,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAA;IAChB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,oDAAoD;IACpD,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,qDAAqD;IACrD,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,yDAAyD;IACzD,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,iDAAiD;IACjD,YAAY,CAAC,EAAE,UAAU,GAAG,UAAU,CAAA;IACtC,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,oBAAoB,GAAG,WAAW,CAcpF"}

package/dist/neutral/modules/network-model/staticRest/paths/chainState.d.ts

@@ -11,4 +11,11 @@ export declare const headPath: () => string;
  * ancestors are sibling files under the same folder. `chainId` is normalized to lowercase.
  */
 export declare const chainContractByIdPath: (chainId: string) => string;
+/**
+ * One immutable version of the chain parameter register. Versions are never rewritten, so a
+ * reader that resolved one can keep using it.
+ */
+export declare const chainParamsVersionPath: (chainId: string, version: number) => string;
+/** The mutable pointer naming the current register version for a chain. */
+export declare const chainParamsHeadPath: (chainId: string) => string;
 //# sourceMappingURL=chainState.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/chainState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chainState.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/chainState.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,kFAAkF;AAClF,eAAO,MAAM,QAAQ,QAAO,MAA2B,CAAA;AAEvD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,KAAG,MAAyD,CAAA"}
+{"version":3,"file":"chainState.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/chainState.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,kFAAkF;AAClF,eAAO,MAAM,QAAQ,QAAO,MAA2B,CAAA;AAEvD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,KAAG,MAAyD,CAAA;AAEjH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,SAAS,MAAM,EAAE,SAAS,MAAM,KAAG,MAChB,CAAA;AAE1D,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,MAA2D,CAAA"}

package/dist/neutral/modules/network-model/staticRest/paths/index.d.ts

@@ -3,5 +3,6 @@ export * from './evmEventIndex.js';
 export * from './finalized.js';
 export * from './indexPaths.js';
 export * from './networkStakeRewardsIndex.js';
+export * from './slashIndex.js';
 export * from './transactionInclusionIndex.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gCAAgC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gCAAgC,CAAA"}

package/dist/neutral/modules/network-model/staticRest/paths/slashIndex.d.ts

@@ -0,0 +1,31 @@
+import type { Hash } from '@ariestools/sdk';
+import type { XyoAddress } from '@xyo-network/sdk';
+import type { OffenseCode } from '../../../protocol-model/index.js';
+/** Path of the mutable slash-index head. */
+export declare function slashIndexHeadPath(): string;
+/** Path of the static slash-index manifest. */
+export declare function slashIndexManifestPath(): string;
+/** Path of one immutable recorded slash request. */
+export declare function slashIndexRequestPath(hash: Hash): string;
+/** Path of one immutable recorded slash commitment. */
+export declare function slashIndexCommitPath(hash: Hash): string;
+/** Path of one immutable recorded slash challenge. */
+export declare function slashIndexChallengePath(hash: Hash): string;
+/** Path of one immutable recorded slash adjudication. */
+export declare function slashIndexAdjudicationPath(hash: Hash): string;
+/**
+ * Path of the aggregate for one offense.
+ *
+ * Keyed by the canonical offense identity rather than by any report, so several reports of the
+ * same misconduct converge on one object instead of accumulating as separate accusations.
+ */
+export declare function slashIndexKeyPath(accused: XyoAddress, offense: OffenseCode, block: number): string;
+/** Path of one producer's offense history. */
+export declare function slashIndexAccusedPath(address: XyoAddress): string;
+/** Path of one reporter's claim history. */
+export declare function slashIndexClaimantPath(address: XyoAddress): string;
+/** Path of one published admission shadow report. */
+export declare function admissionShadowPath(height: number): string;
+/** Path of the mutable pointer to the newest admission shadow report. */
+export declare function admissionShadowHeadPath(): string;
+//# sourceMappingURL=slashIndex.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/slashIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/slashIndex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAIlD,4CAA4C;AAC5C,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,+CAA+C;AAC/C,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED,oDAAoD;AACpD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAExD;AAED,uDAAuD;AACvD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEvD;AAED,sDAAsD;AACtD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE1D;AAED,yDAAyD;AACzD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAElG;AAED,8CAA8C;AAC9C,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAEjE;AAED,4CAA4C;AAC5C,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAElE;AAED,qDAAqD;AACrD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,yEAAyE;AACzE,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/neutral/modules/protocol-lib/validation/payload/InBlockPayloadValidationFunction.d.ts

@@ -1,9 +1,43 @@
-import type { Promisable } from '@ariestools/sdk';
+import type { Hash, Promisable } from '@ariestools/sdk';
 import type { Payload, WithHashMeta } from '@xyo-network/sdk';
-import type { BaseContext, HydratedBlockWithHashMeta } from '../../../protocol-model/index.js';
+import type { BaseContext, HydratedBlockWithHashMeta, RuleActivationParams, XL1BlockNumber } from '../../../protocol-model/index.js';
 import type { InBlockPayloadValidationError } from './error.js';
-/** Context for InBlockPayloadValidationFunction operations. */
+/**
+ * The register facts an in-block validator is allowed to ask about.
+ *
+ * Deliberately a view rather than the register document: a validator needs to know which rules
+ * are on and the few numbers those rules quote, and widening this to the whole document would
+ * let block validity start depending on parameters nobody meant to make consensus-critical. A
+ * full register version satisfies this structurally, so no conversion is needed.
+ */
+export interface InBlockRuleParams extends RuleActivationParams {
+    /** Address whose adjudication records are honored. */
+    arbiter?: string;
+    /** Refundable deposit a report must escrow, in the smallest unit. */
+    reporterDepositAtto?: string;
+}
+/**
+ * Context for InBlockPayloadValidationFunction operations.
+ *
+ * Both fields are optional because a node running the trusted posture wires neither, and the
+ * validators are written so that absence reproduces pre-upgrade behavior exactly.
+ */
 export interface InBlockPayloadValidationFunctionContext extends BaseContext {
+    /**
+     * Whether an evidence artifact was carried by an already-finalized block.
+     *
+     * Absent on a node that has not deployed the evidence subsystem. Validators gated on a rule
+     * that needs this must fail closed when it is missing: a node that cannot check a requirement
+     * cannot certify the block.
+     */
+    hasFinalizedEvidenceArtifact?: (hash: Hash, height: XL1BlockNumber) => Promisable<boolean>;
+    /**
+     * The register version in force at a height.
+     *
+     * Absent when no register is wired, which is how a chain declares it is running exactly as it
+     * did before any of this existed.
+     */
+    paramsAtHeight?: (height: XL1BlockNumber) => Promisable<InBlockRuleParams | undefined>;
 }
 /** Function type for InBlockPayloadValidation operations. */
 export type InBlockPayloadValidationFunction = (context: InBlockPayloadValidationFunctionContext, payload: WithHashMeta<Payload>, block: HydratedBlockWithHashMeta) => Promisable<InBlockPayloadValidationError[]>;

package/dist/neutral/modules/protocol-lib/validation/payload/InBlockPayloadValidationFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InBlockPayloadValidationFunction.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/payload/InBlockPayloadValidationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAA;AAE7E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAA;AAE/D,+DAA+D;AAC/D,MAAM,WAAW,uCAAwC,SAAQ,WAAW;CAE3E;AAED,6DAA6D;AAC7D,MAAM,MAAM,gCAAgC,GAAG,CAC7C,OAAO,EAAE,uCAAuC,EAChD,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,yBAAyB,KAC7D,UAAU,CAAC,6BAA6B,EAAE,CAAC,CAAA"}
+{"version":3,"file":"InBlockPayloadValidationFunction.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/payload/InBlockPayloadValidationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE7D,OAAO,KAAK,EACV,WAAW,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,cAAc,EAC7E,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAA;AAE/D;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED;;;;;GAKG;AACH,MAAM,WAAW,uCAAwC,SAAQ,WAAW;IAC1E;;;;;;OAMG;IACH,4BAA4B,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,KAAK,UAAU,CAAC,OAAO,CAAC,CAAA;IAC1F;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,UAAU,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAA;CACvF;AAED,6DAA6D;AAC7D,MAAM,MAAM,gCAAgC,GAAG,CAC7C,OAAO,EAAE,uCAAuC,EAChD,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,yBAAyB,KAC7D,UAAU,CAAC,6BAA6B,EAAE,CAAC,CAAA"}

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

@@ -1,3 +1,4 @@
 export * from './error.js';
 export * from './InBlockPayloadValidationFunction.js';
+export * from './ruleGate.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,uCAAuC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,uCAAuC,CAAA;AACrD,cAAc,eAAe,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/payload/ruleGate.d.ts

@@ -0,0 +1,29 @@
+import type { RuleId, XL1BlockNumber } from '../../../protocol-model/index.js';
+import type { InBlockPayloadValidationFunctionContext, InBlockRuleParams } from './InBlockPayloadValidationFunction.js';
+/**
+ * The register version in force at a height, or undefined when none can be resolved.
+ * @param context The validation context, which may carry no register at all
+ * @param height The XL1 height being judged
+ * @returns The rules in force, or undefined
+ */
+export declare function resolveRuleParams(context: InBlockPayloadValidationFunctionContext, height: XL1BlockNumber): Promise<InBlockRuleParams | undefined>;
+/**
+ * Why a rule-gated payload is not admissible at a height, or undefined when it is.
+ *
+ * This is the one place the fail-open rule is written down, and every rule-gated validator must
+ * come through it. An unresolved register is treated as activating nothing, so a node with no
+ * register rejects a gated payload for the same reason pre-upgrade software does — it does not
+ * recognize it. Getting that equivalence wrong in either direction splits consensus: reject where
+ * others accept, and an upgraded node forks itself off; accept where others reject, and a
+ * payload becomes admissible before the network agreed it was.
+ *
+ * Note this asks the strict question. Inside a grace band the rule is observed but not enforced,
+ * and a payload nobody has agreed to admit yet stays inadmissible.
+ * @param params The rules in force, or undefined when none resolved
+ * @param ruleId The rule that must be active
+ * @param height The XL1 height being judged
+ * @param subject What is being gated, named for the error message
+ * @returns The reason it is inadmissible, or undefined when it is admissible
+ */
+export declare function requireRuleActive(params: InBlockRuleParams | undefined, ruleId: RuleId, height: number, subject: string): string | undefined;
+//# sourceMappingURL=ruleGate.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/payload/ruleGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruleGate.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/payload/ruleGate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAG7D,OAAO,KAAK,EAAE,uCAAuC,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAA;AAEvH;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,uCAAuC,EAChD,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAExC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,GAAG,SAAS,EACrC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAMpB"}

package/dist/neutral/modules/protocol-lib/viewers/ChainParams.d.ts

@@ -0,0 +1,26 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { ChainParams } from '../../network-model/index.js';
+import type { Provider } from '../../protocol-model/index.js';
+/** Operations exposed by the Chain Params Viewer contract. */
+export interface ChainParamsViewerMethods {
+    /** The current register version, throwing when none can be resolved. */
+    currentParams(): Promisable<ChainParams>;
+    /** A specific register version, or null when it is not published. */
+    paramsByVersion(version: number): Promisable<ChainParams | null>;
+    /**
+     * The current register version, or undefined when none can be resolved.
+     *
+     * Callers use this rather than the throwing form when a missing register has a defined
+     * meaning: before enforcement exists, no register means no rules are on, and a node that
+     * cannot read one must keep running rather than stop.
+     */
+    tryCurrentParams(): Promisable<ChainParams | undefined>;
+}
+/** Moniker identifier for the ChainParamsViewer provider. */
+export declare const ChainParamsViewerMoniker: "ChainParamsViewer";
+/** Type literal for the ChainParamsViewer provider moniker. */
+export type ChainParamsViewerMoniker = typeof ChainParamsViewerMoniker;
+/** Viewer interface for reading the chain parameter register. */
+export interface ChainParamsViewer extends ChainParamsViewerMethods, Provider<ChainParamsViewerMoniker> {
+}
+//# sourceMappingURL=ChainParams.d.ts.map

package/dist/neutral/modules/protocol-lib/viewers/ChainParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainParams.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/viewers/ChainParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C,8DAA8D;AAC9D,MAAM,WAAW,wBAAwB;IACvC,wEAAwE;IACxE,aAAa,IAAI,UAAU,CAAC,WAAW,CAAC,CAAA;IACxC,qEAAqE;IACrE,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IAChE;;;;;;OAMG;IACH,gBAAgB,IAAI,UAAU,CAAC,WAAW,GAAG,SAAS,CAAC,CAAA;CACxD;AAED,6DAA6D;AAC7D,eAAO,MAAM,wBAAwB,EAAG,mBAA4B,CAAA;AACpE,+DAA+D;AAC/D,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAA;AAEtE,iEAAiE;AACjE,MAAM,WAAW,iBAAkB,SAAQ,wBAAwB,EAAE,QAAQ,CAAC,wBAAwB,CAAC;CAAG"}

package/dist/neutral/modules/protocol-lib/viewers/index.d.ts

@@ -3,6 +3,7 @@ export * from './BlockInvalidation.js';
 export * from './BlockReward.js';
 export * from './BlockValidation.js';
 export * from './ChainContract.js';
+export * from './ChainParams.js';
 export * from './ChainStakeViewer.js';
 export * from './ChainState.js';
 export * from './DeadLetterQueue.js';

package/dist/neutral/modules/protocol-lib/viewers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/viewers/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,WAAW,CAAA;AACzB,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,yBAAyB,CAAA;AACvC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/viewers/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,WAAW,CAAA;AACzB,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,yBAAyB,CAAA;AACvC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA"}

package/dist/neutral/modules/protocol-model/block/AllowedBlockPayload.d.ts

@@ -1,10 +1,10 @@
 import type { SchemaPayload, WithStorageMeta } from '@xyo-network/sdk';
 import { z } from 'zod';
-import type { BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation, ChainStakeIntent, HashPayload, StepComplete, TimePayload } from '../payload/index.js';
+import type { BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation, ChainStakeIntent, HashPayload, SlashAdjudication, SlashChallenge, SlashCommit, SlashEvidence, SlashRequest, StepComplete, StepWitness, TimePayload } from '../payload/index.js';
 import { type TransactionBoundWitness } from '../transaction/index.js';
 import { type Transfer } from '../TransferPayload.js';
 /** Validated data representation for Allowed Block Payload. */
-export type AllowedBlockPayload = BridgeDestinationObservation | BridgeIntent | BridgeSourceObservation | ChainStakeIntent | HashPayload | SchemaPayload | StepComplete | TimePayload | TransactionBoundWitness | Transfer;
+export type AllowedBlockPayload = BridgeDestinationObservation | BridgeIntent | BridgeSourceObservation | ChainStakeIntent | HashPayload | SchemaPayload | SlashAdjudication | SlashChallenge | SlashCommit | SlashEvidence | SlashRequest | StepWitness | StepComplete | TimePayload | TransactionBoundWitness | Transfer;
 /** Schema identifiers accepted by the Allowed Block Payload contract. */
 export declare const AllowedBlockPayloadSchemas: (("network.xyo.chain.bridge.observation.destination" & {
     readonly __schema: true;
@@ -20,6 +20,18 @@ export declare const AllowedBlockPayloadSchemas: (("network.xyo.chain.bridge.obs
     readonly __schema: true;
 }) | ("network.xyo.time" & {
     readonly __schema: true;
+}) | ("network.xyo.chain.slash.adjudication" & {
+    readonly __schema: true;
+}) | ("network.xyo.chain.slash.challenge" & {
+    readonly __schema: true;
+}) | ("network.xyo.chain.slash.commit" & {
+    readonly __schema: true;
+}) | ("network.xyo.chain.slash.evidence" & {
+    readonly __schema: true;
+}) | ("network.xyo.chain.slash.request" & {
+    readonly __schema: true;
+}) | ("network.xyo.chain.validation.step.witness" & {
+    readonly __schema: true;
 }) | ("network.xyo.transfer" & {
     readonly __schema: true;
 }) | ("network.xyo.boundwitness" & {

package/dist/neutral/modules/protocol-model/block/AllowedBlockPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AllowedBlockPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/block/AllowedBlockPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACF,aAAa,EAAE,eAAe,EACvC,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EACV,4BAA4B,EAAE,YAAY,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAC9H,MAAM,qBAAqB,CAAA;AAM5B,OAAO,EAA6B,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AACjG,OAAO,EACO,KAAK,QAAQ,EAC1B,MAAM,uBAAuB,CAAA;AAE9B,+DAA+D;AAC/D,MAAM,MAAM,mBAAmB,GACzB,4BAA4B,GAC5B,YAAY,GACZ,uBAAuB,GACvB,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,uBAAuB,GACvB,QAAQ,CAAA;AAEd,yEAAyE;AACzE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;KAWnB,CAAA;AAEpB,qEAAqE;AACrE,eAAO,MAAM,4BAA4B,eAAqC,CAAA;AAC9E,oDAAoD;AACpD,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACpF,4DAA4D;AAC5D,eAAO,MAAM,2BAA2B,6BAA6C,CAAA;AAErF,wEAAwE;AACxE,eAAO,MAAM,qBAAqB,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,mBAAmB,GAAG,CAelF,CAAA;AAED,oFAAoF;AACpF,eAAO,MAAM,iCAAiC,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,eAAe,CAAC,mBAAmB,GAAG,CAAC,CAE/G,CAAA"}
+{"version":3,"file":"AllowedBlockPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/block/AllowedBlockPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACF,aAAa,EAAE,eAAe,EACvC,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EACV,4BAA4B,EAAE,YAAY,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,WAAW,EAClG,iBAAiB,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EACpH,MAAM,qBAAqB,CAAA;AAQ5B,OAAO,EAA6B,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AACjG,OAAO,EACO,KAAK,QAAQ,EAC1B,MAAM,uBAAuB,CAAA;AAE9B,+DAA+D;AAC/D,MAAM,MAAM,mBAAmB,GACzB,4BAA4B,GAC5B,YAAY,GACZ,uBAAuB,GACvB,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,iBAAiB,GACjB,cAAc,GACd,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,WAAW,GACX,uBAAuB,GACvB,QAAQ,CAAA;AAEd,yEAAyE;AACzE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiBnB,CAAA;AAEpB,qEAAqE;AACrE,eAAO,MAAM,4BAA4B,eAAqC,CAAA;AAC9E,oDAAoD;AACpD,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACpF,4DAA4D;AAC5D,eAAO,MAAM,2BAA2B,6BAA6C,CAAA;AAErF,wEAAwE;AACxE,eAAO,MAAM,qBAAqB,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,mBAAmB,GAAG,CAqBlF,CAAA;AAED,oFAAoF;AACpF,eAAO,MAAM,iCAAiC,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,eAAe,CAAC,mBAAmB,GAAG,CAAC,CAE/G,CAAA"}