@xyo-network/xl1-protocol 5.1.4 → 5.2.1

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

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+/** Schema id for a published admission shadow report. */
+export declare const AdmissionShadowReportSchema: "network.xyo.s3.admission.shadow" & {
+    readonly __schema: true;
+};
+/** Type literal for the admission shadow report schema. */
+export type AdmissionShadowReportSchema = typeof AdmissionShadowReportSchema;
+/** What both admission gates concluded about one candidate. */
+export declare const AdmissionShadowAssessmentZod: z.ZodObject<{
+    admittedByAllowList: z.ZodBoolean;
+    block: z.ZodInt;
+    dataHash: z.ZodString;
+    eStar: z.ZodOptional<z.ZodInt>;
+    eligible: z.ZodOptional<z.ZodBoolean>;
+    producer: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    resolvable: z.ZodBoolean;
+}, z.core.$strip>;
+/** What both admission gates concluded about one candidate. */
+export type AdmissionShadowAssessment = z.infer<typeof AdmissionShadowAssessmentZod>;
+/**
+ * Zod schema for one published round of shadow admission.
+ *
+ * Published rather than logged because the point of the posture is that anyone can see what
+ * enforcement would have done before it does it. An operator convinced by their own logs has
+ * convinced nobody.
+ *
+ * The back-link is what makes the series walkable without listing: a reader takes the head
+ * pointer and follows `previous` as far back as it cares to.
+ */
+export declare const AdmissionShadowReportZod: z.ZodObject<{
+    assessments: z.ZodArray<z.ZodObject<{
+        admittedByAllowList: z.ZodBoolean;
+        block: z.ZodInt;
+        dataHash: z.ZodString;
+        eStar: z.ZodOptional<z.ZodInt>;
+        eligible: z.ZodOptional<z.ZodBoolean>;
+        producer: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        resolvable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    divergent: z.ZodArray<z.ZodObject<{
+        admittedByAllowList: z.ZodBoolean;
+        block: z.ZodInt;
+        dataHash: z.ZodString;
+        eStar: z.ZodOptional<z.ZodInt>;
+        eligible: z.ZodOptional<z.ZodBoolean>;
+        producer: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        resolvable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    head: z.ZodInt;
+    previous: z.ZodOptional<z.ZodInt>;
+    schema: z.ZodLiteral<"network.xyo.s3.admission.shadow" & {
+        readonly __schema: true;
+    }>;
+}, z.core.$strip>;
+/** One published round of shadow admission. */
+export type AdmissionShadowReportDocument = z.infer<typeof AdmissionShadowReportZod>;
+/** Type guard that checks if a value is a valid AdmissionShadowReportDocument. */
+export declare const isAdmissionShadowReport: <T>(value: T) => value is T & {
+    assessments: {
+        admittedByAllowList: boolean;
+        block: number;
+        dataHash: string;
+        producer: string;
+        resolvable: boolean;
+        eStar?: number | undefined;
+        eligible?: boolean | undefined;
+        reason?: string | undefined;
+    }[];
+    divergent: {
+        admittedByAllowList: boolean;
+        block: number;
+        dataHash: string;
+        producer: string;
+        resolvable: boolean;
+        eStar?: number | undefined;
+        eligible?: boolean | undefined;
+        reason?: string | undefined;
+    }[];
+    head: number;
+    schema: "network.xyo.s3.admission.shadow" & {
+        readonly __schema: true;
+    };
+    previous?: number | undefined;
+};
+/** Converts a value to AdmissionShadowReportDocument, throwing if invalid. */
+export declare const asAdmissionShadowReport: {
+    <T>(value: T): (T & {
+        assessments: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            reason?: string | undefined;
+        }[];
+        divergent: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            reason?: string | undefined;
+        }[];
+        head: number;
+        schema: "network.xyo.s3.admission.shadow" & {
+            readonly __schema: true;
+        };
+        previous?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        assessments: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            reason?: string | undefined;
+        }[];
+        divergent: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            reason?: string | undefined;
+        }[];
+        head: number;
+        schema: "network.xyo.s3.admission.shadow" & {
+            readonly __schema: true;
+        };
+        previous?: number | undefined;
+    };
+};
+/** Builds a validated admission shadow report. */
+export declare function createAdmissionShadowReport(head: number, assessments: AdmissionShadowAssessment[], divergent: AdmissionShadowAssessment[], previous?: number): AdmissionShadowReportDocument;
+//# sourceMappingURL=admissionShadow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"admissionShadow.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/admissionShadow.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,yDAAyD;AACzD,eAAO,MAAM,2BAA2B;;CAAoD,CAAA;AAC5F,2DAA2D;AAC3D,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA;AAE5E,+DAA+D;AAC/D,eAAO,MAAM,4BAA4B;;;;;;;;;iBAiBvC,CAAA;AAEF,+DAA+D;AAC/D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUnC,CAAA;AAEF,+CAA+C;AAC/C,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,kFAAkF;AAClF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA;AAC7E,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AAExG,kDAAkD;AAClD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,yBAAyB,EAAE,EACxC,SAAS,EAAE,yBAAyB,EAAE,EACtC,QAAQ,CAAC,EAAE,MAAM,GAChB,6BAA6B,CAI/B"}

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

@@ -0,0 +1,371 @@
+import { z } from 'zod';
+/** Schema id for the chain parameter register document. */
+export declare const ChainParamsSchema: "network.xyo.s3.chain.params" & {
+    readonly __schema: true;
+};
+/** Type literal for the chain parameter register schema. */
+export type ChainParamsSchema = typeof ChainParamsSchema;
+/** Bumped when the register shape changes, so readers can detect a mismatch. */
+export declare const CHAIN_PARAMS_VERSION = 1;
+/** Zod schema for a rule identifier. */
+export declare const RuleIdZod: z.ZodEnum<{
+    "intent-binding": "intent-binding";
+    "anchor-rules": "anchor-rules";
+    "single-signer": "single-signer";
+    "supersedes-field": "supersedes-field";
+    "slash-payloads": "slash-payloads";
+    "eligibility-admission": "eligibility-admission";
+    "attestation-admission": "attestation-admission";
+    "certificate-execution": "certificate-execution";
+    "equivocation.reportable": "equivocation.reportable";
+    "invalid-block.reportable": "invalid-block.reportable";
+    "reward-overmint.reportable": "reward-overmint.reportable";
+    "false-anchor.reportable": "false-anchor.reportable";
+    "ineligible-production.reportable": "ineligible-production.reportable";
+    "invalid-slash-request.reportable": "invalid-slash-request.reportable";
+    "false-attestation.reportable": "false-attestation.reportable";
+    "equivocation.adjudicable": "equivocation.adjudicable";
+    "invalid-block.adjudicable": "invalid-block.adjudicable";
+    "reward-overmint.adjudicable": "reward-overmint.adjudicable";
+    "false-anchor.adjudicable": "false-anchor.adjudicable";
+    "ineligible-production.adjudicable": "ineligible-production.adjudicable";
+    "invalid-slash-request.adjudicable": "invalid-slash-request.adjudicable";
+    "false-attestation.adjudicable": "false-attestation.adjudicable";
+}>;
+/**
+ * Zod schema for one version of the chain parameter register.
+ *
+ * The register is the control plane: which rules are on, from what height, and the numbers they
+ * use. A register that activates nothing describes a network running exactly as it did before
+ * any of this existed, which is what makes trusted operation a posture rather than an old build.
+ */
+export declare const ChainParamsZod: z.ZodObject<{
+    activations: z.ZodRecord<z.ZodEnum<{
+        "intent-binding": "intent-binding";
+        "anchor-rules": "anchor-rules";
+        "single-signer": "single-signer";
+        "supersedes-field": "supersedes-field";
+        "slash-payloads": "slash-payloads";
+        "eligibility-admission": "eligibility-admission";
+        "attestation-admission": "attestation-admission";
+        "certificate-execution": "certificate-execution";
+        "equivocation.reportable": "equivocation.reportable";
+        "invalid-block.reportable": "invalid-block.reportable";
+        "reward-overmint.reportable": "reward-overmint.reportable";
+        "false-anchor.reportable": "false-anchor.reportable";
+        "ineligible-production.reportable": "ineligible-production.reportable";
+        "invalid-slash-request.reportable": "invalid-slash-request.reportable";
+        "false-attestation.reportable": "false-attestation.reportable";
+        "equivocation.adjudicable": "equivocation.adjudicable";
+        "invalid-block.adjudicable": "invalid-block.adjudicable";
+        "reward-overmint.adjudicable": "reward-overmint.adjudicable";
+        "false-anchor.adjudicable": "false-anchor.adjudicable";
+        "ineligible-production.adjudicable": "ineligible-production.adjudicable";
+        "invalid-slash-request.adjudicable": "invalid-slash-request.adjudicable";
+        "false-attestation.adjudicable": "false-attestation.adjudicable";
+    }> & z.core.$partial, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>, z.ZodInt>>;
+    arbiter: z.ZodString;
+    attestationRewardBps: z.ZodInt;
+    bountyCapAtto: z.ZodString;
+    bountyShareBps: z.ZodInt;
+    burnFloorBps: z.ZodInt;
+    catalogVersion: z.ZodInt;
+    chainId: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    challengeWindowEvmBlocks: z.ZodInt;
+    deactivations: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        "intent-binding": "intent-binding";
+        "anchor-rules": "anchor-rules";
+        "single-signer": "single-signer";
+        "supersedes-field": "supersedes-field";
+        "slash-payloads": "slash-payloads";
+        "eligibility-admission": "eligibility-admission";
+        "attestation-admission": "attestation-admission";
+        "certificate-execution": "certificate-execution";
+        "equivocation.reportable": "equivocation.reportable";
+        "invalid-block.reportable": "invalid-block.reportable";
+        "reward-overmint.reportable": "reward-overmint.reportable";
+        "false-anchor.reportable": "false-anchor.reportable";
+        "ineligible-production.reportable": "ineligible-production.reportable";
+        "invalid-slash-request.reportable": "invalid-slash-request.reportable";
+        "false-attestation.reportable": "false-attestation.reportable";
+        "equivocation.adjudicable": "equivocation.adjudicable";
+        "invalid-block.adjudicable": "invalid-block.adjudicable";
+        "reward-overmint.adjudicable": "reward-overmint.adjudicable";
+        "false-anchor.adjudicable": "false-anchor.adjudicable";
+        "ineligible-production.adjudicable": "ineligible-production.adjudicable";
+        "invalid-slash-request.adjudicable": "invalid-slash-request.adjudicable";
+        "false-attestation.adjudicable": "false-attestation.adjudicable";
+    }> & z.core.$partial, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>, z.ZodInt>>>;
+    evidenceFreshnessEvmBlocks: z.ZodInt;
+    evidenceRetentionXl1Blocks: z.ZodInt;
+    executionDelayEvmBlocks: z.ZodInt;
+    freshnessBandEvmBlocks: z.ZodInt;
+    graceBandXl1Blocks: z.ZodInt;
+    maturityEvmBlocks: z.ZodInt;
+    minProducerSelfBondAtto: z.ZodString;
+    minProducerStakeAtto: z.ZodString;
+    minStakeAgeEvmBlocks: z.ZodInt;
+    minValidatorStakeAtto: z.ZodString;
+    opsAllowanceEvmBlocks: z.ZodInt;
+    protocolMin: z.ZodInt;
+    reporterDepositAtto: z.ZodString;
+    revealDelayEvmBlocks: z.ZodInt;
+    revealDelayXl1Blocks: z.ZodInt;
+    revealWindowEvmBlocks: z.ZodInt;
+    revealWindowXl1Blocks: z.ZodInt;
+    rewardSource: z.ZodEnum<{
+        schedule: "schedule";
+        contract: "contract";
+    }>;
+    schema: z.ZodLiteral<"network.xyo.s3.chain.params" & {
+        readonly __schema: true;
+    }>;
+    slashFractionsBps: z.ZodRecord<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";
+    }> & z.core.$partial, z.ZodInt>;
+    slashQuorumCount: z.ZodInt;
+    version: z.ZodInt;
+}, z.core.$strip>;
+/** One version of the chain parameter register. */
+export type ChainParams = z.infer<typeof ChainParamsZod>;
+/** Numeric-input-tolerant shape accepted when creating a register version. */
+export type ChainParamsInput = z.input<typeof ChainParamsZod>;
+/** Type guard that checks if a value is a valid ChainParams. */
+export declare const isChainParams: <T>(value: T) => value is T & {
+    activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+    arbiter: string;
+    attestationRewardBps: number;
+    bountyCapAtto: string;
+    bountyShareBps: number;
+    burnFloorBps: number;
+    catalogVersion: number;
+    chainId: import("@ariestools/sdk").BrandedHex;
+    challengeWindowEvmBlocks: number;
+    evidenceFreshnessEvmBlocks: number;
+    evidenceRetentionXl1Blocks: number;
+    executionDelayEvmBlocks: number;
+    freshnessBandEvmBlocks: number;
+    graceBandXl1Blocks: number;
+    maturityEvmBlocks: number;
+    minProducerSelfBondAtto: string;
+    minProducerStakeAtto: string;
+    minStakeAgeEvmBlocks: number;
+    minValidatorStakeAtto: string;
+    opsAllowanceEvmBlocks: number;
+    protocolMin: number;
+    reporterDepositAtto: string;
+    revealDelayEvmBlocks: number;
+    revealDelayXl1Blocks: number;
+    revealWindowEvmBlocks: number;
+    revealWindowXl1Blocks: number;
+    rewardSource: "schedule" | "contract";
+    schema: "network.xyo.s3.chain.params" & {
+        readonly __schema: true;
+    };
+    slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
+    slashQuorumCount: number;
+    version: number;
+    deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+};
+/** Converts a value to ChainParams, throwing if invalid. */
+export declare const asChainParams: {
+    <T>(value: T): (T & {
+        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+        arbiter: string;
+        attestationRewardBps: number;
+        bountyCapAtto: string;
+        bountyShareBps: number;
+        burnFloorBps: number;
+        catalogVersion: number;
+        chainId: import("@ariestools/sdk").BrandedHex;
+        challengeWindowEvmBlocks: number;
+        evidenceFreshnessEvmBlocks: number;
+        evidenceRetentionXl1Blocks: number;
+        executionDelayEvmBlocks: number;
+        freshnessBandEvmBlocks: number;
+        graceBandXl1Blocks: number;
+        maturityEvmBlocks: number;
+        minProducerSelfBondAtto: string;
+        minProducerStakeAtto: string;
+        minStakeAgeEvmBlocks: number;
+        minValidatorStakeAtto: string;
+        opsAllowanceEvmBlocks: number;
+        protocolMin: number;
+        reporterDepositAtto: string;
+        revealDelayEvmBlocks: number;
+        revealDelayXl1Blocks: number;
+        revealWindowEvmBlocks: number;
+        revealWindowXl1Blocks: number;
+        rewardSource: "schedule" | "contract";
+        schema: "network.xyo.s3.chain.params" & {
+            readonly __schema: true;
+        };
+        slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
+        slashQuorumCount: number;
+        version: number;
+        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+        arbiter: string;
+        attestationRewardBps: number;
+        bountyCapAtto: string;
+        bountyShareBps: number;
+        burnFloorBps: number;
+        catalogVersion: number;
+        chainId: import("@ariestools/sdk").BrandedHex;
+        challengeWindowEvmBlocks: number;
+        evidenceFreshnessEvmBlocks: number;
+        evidenceRetentionXl1Blocks: number;
+        executionDelayEvmBlocks: number;
+        freshnessBandEvmBlocks: number;
+        graceBandXl1Blocks: number;
+        maturityEvmBlocks: number;
+        minProducerSelfBondAtto: string;
+        minProducerStakeAtto: string;
+        minStakeAgeEvmBlocks: number;
+        minValidatorStakeAtto: string;
+        opsAllowanceEvmBlocks: number;
+        protocolMin: number;
+        reporterDepositAtto: string;
+        revealDelayEvmBlocks: number;
+        revealDelayXl1Blocks: number;
+        revealWindowEvmBlocks: number;
+        revealWindowXl1Blocks: number;
+        rewardSource: "schedule" | "contract";
+        schema: "network.xyo.s3.chain.params" & {
+            readonly __schema: true;
+        };
+        slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
+        slashQuorumCount: number;
+        version: number;
+        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+    };
+};
+/** Non-validating cast to ChainParams. */
+export declare const toChainParams: {
+    (value: unknown): {
+        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+        arbiter: string;
+        attestationRewardBps: number;
+        bountyCapAtto: string;
+        bountyShareBps: number;
+        burnFloorBps: number;
+        catalogVersion: number;
+        chainId: import("@ariestools/sdk").BrandedHex;
+        challengeWindowEvmBlocks: number;
+        evidenceFreshnessEvmBlocks: number;
+        evidenceRetentionXl1Blocks: number;
+        executionDelayEvmBlocks: number;
+        freshnessBandEvmBlocks: number;
+        graceBandXl1Blocks: number;
+        maturityEvmBlocks: number;
+        minProducerSelfBondAtto: string;
+        minProducerStakeAtto: string;
+        minStakeAgeEvmBlocks: number;
+        minValidatorStakeAtto: string;
+        opsAllowanceEvmBlocks: number;
+        protocolMin: number;
+        reporterDepositAtto: string;
+        revealDelayEvmBlocks: number;
+        revealDelayXl1Blocks: number;
+        revealWindowEvmBlocks: number;
+        revealWindowXl1Blocks: number;
+        rewardSource: "schedule" | "contract";
+        schema: "network.xyo.s3.chain.params" & {
+            readonly __schema: true;
+        };
+        slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
+        slashQuorumCount: number;
+        version: number;
+        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        activations: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>>;
+        arbiter: string;
+        attestationRewardBps: number;
+        bountyCapAtto: string;
+        bountyShareBps: number;
+        burnFloorBps: number;
+        catalogVersion: number;
+        chainId: import("@ariestools/sdk").BrandedHex;
+        challengeWindowEvmBlocks: number;
+        evidenceFreshnessEvmBlocks: number;
+        evidenceRetentionXl1Blocks: number;
+        executionDelayEvmBlocks: number;
+        freshnessBandEvmBlocks: number;
+        graceBandXl1Blocks: number;
+        maturityEvmBlocks: number;
+        minProducerSelfBondAtto: string;
+        minProducerStakeAtto: string;
+        minStakeAgeEvmBlocks: number;
+        minValidatorStakeAtto: string;
+        opsAllowanceEvmBlocks: number;
+        protocolMin: number;
+        reporterDepositAtto: string;
+        revealDelayEvmBlocks: number;
+        revealDelayXl1Blocks: number;
+        revealWindowEvmBlocks: number;
+        revealWindowXl1Blocks: number;
+        rewardSource: "schedule" | "contract";
+        schema: "network.xyo.s3.chain.params" & {
+            readonly __schema: true;
+        };
+        slashFractionsBps: Partial<Record<"equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation", number>>;
+        slashQuorumCount: number;
+        version: number;
+        deactivations?: Partial<Record<"intent-binding" | "anchor-rules" | "single-signer" | "supersedes-field" | "slash-payloads" | "eligibility-admission" | "attestation-admission" | "certificate-execution" | "equivocation.reportable" | "invalid-block.reportable" | "reward-overmint.reportable" | "false-anchor.reportable" | "ineligible-production.reportable" | "invalid-slash-request.reportable" | "false-attestation.reportable" | "equivocation.adjudicable" | "invalid-block.adjudicable" | "reward-overmint.adjudicable" | "false-anchor.adjudicable" | "ineligible-production.adjudicable" | "invalid-slash-request.adjudicable" | "false-attestation.adjudicable", number>> | undefined;
+    };
+};
+/** Schema id for the register head pointer. */
+export declare const ChainParamsHeadSchema: "network.xyo.s3.chain.params.head" & {
+    readonly __schema: true;
+};
+/** Type literal for the register head schema. */
+export type ChainParamsHeadSchema = typeof ChainParamsHeadSchema;
+/** Zod schema for the mutable pointer naming the current register version. */
+export declare const ChainParamsHeadZod: z.ZodObject<{
+    hash: z.ZodString;
+    schema: z.ZodLiteral<"network.xyo.s3.chain.params.head" & {
+        readonly __schema: true;
+    }>;
+    version: z.ZodInt;
+}, z.core.$strip>;
+/** The mutable pointer naming the current register version. */
+export type ChainParamsHead = z.infer<typeof ChainParamsHeadZod>;
+/** Type guard that checks if a value is a valid ChainParamsHead. */
+export declare const isChainParamsHead: <T>(value: T) => value is T & {
+    hash: string;
+    schema: "network.xyo.s3.chain.params.head" & {
+        readonly __schema: true;
+    };
+    version: number;
+};
+/** Converts a value to ChainParamsHead, throwing if invalid. */
+export declare const asChainParamsHead: {
+    <T>(value: T): (T & {
+        hash: string;
+        schema: "network.xyo.s3.chain.params.head" & {
+            readonly __schema: true;
+        };
+        version: number;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        hash: string;
+        schema: "network.xyo.s3.chain.params.head" & {
+            readonly __schema: true;
+        };
+        version: number;
+    };
+};
+/** Builds a validated register version. */
+export declare function createChainParams(config: Omit<ChainParamsInput, 'schema'>): ChainParams;
+/** Builds a validated register head pointer. */
+export declare function createChainParamsHead(version: number, hash: string): ChainParamsHead;
+//# sourceMappingURL=chainParams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chainParams.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/chainParams.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB;;CAAgD,CAAA;AAC9E,4DAA4D;AAC5D,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAKrC,wCAAwC;AACxC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;EAAkB,CAAA;AAKxC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgEzB,CAAA;AAEF,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE7D,gEAAgE;AAChE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+B,CAAA;AACzD,4DAA4D;AAC5D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAC1E,0CAA0C;AAC1C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAE1E,+CAA+C;AAC/C,eAAO,MAAM,qBAAqB;;CAAqD,CAAA;AACvF,iDAAiD;AACjD,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAA;AAEhE,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,CAAA;AAEF,+DAA+D;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,oEAAoE;AACpE,eAAO,MAAM,iBAAiB;;;;;;CAAmC,CAAA;AACjE,gEAAgE;AAChE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CAAwD,CAAA;AAEtF,2CAA2C;AAC3C,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,GAAG,WAAW,CAEvF;AAED,gDAAgD;AAChD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAIpF"}

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

@@ -0,0 +1,36 @@
+import type { OffenseCode, RuleActivationState } from '../../../protocol-model/index.js';
+import type { ChainParams } from './chainParams.js';
+/** Whether reports naming an offense at a height may be recorded. */
+export declare function isOffenseReportableAt(params: ChainParams, offense: OffenseCode, height: number): boolean;
+/**
+ * Where an offense stands for adjudication at a height.
+ *
+ * Callers need the three-way answer rather than a boolean: inside the grace band a report is
+ * still verified and recorded, it simply cannot be confirmed against anyone.
+ */
+export declare function offenseAdjudicationStateAt(params: ChainParams, offense: OffenseCode, height: number): RuleActivationState;
+/**
+ * The lowest protocol version a block at this height may declare, or undefined when nothing is
+ * required yet.
+ *
+ * The floor rides with the anchor rules, since that is the release the version stamp first has to
+ * mean something. Before then `block.protocol` is declared but unchecked, and rejecting on it
+ * would fail blocks that were valid when they were made.
+ * @param params The register version in force
+ * @param height The XL1 height being judged
+ * @returns The minimum protocol version, or undefined when unenforced
+ */
+export declare function protocolMinAt(params: ChainParams, height: number): number | undefined;
+/**
+ * Checks that a new register version may follow the one already published.
+ *
+ * The register is append-only over history: a version may add rules and move future heights, but
+ * never rewrite what was true at a height the chain has already passed. Without that, a rule
+ * could be made retroactive and blocks that were valid when produced would become offenses.
+ * @param previous The currently published version, when there is one
+ * @param next The version being published
+ * @param finalizedHeight The current finalized head height
+ * @returns The reasons the version may not be published, empty when it may
+ */
+export declare function chainParamsSuccessionErrors(previous: ChainParams | undefined, next: ChainParams, finalizedHeight: number): string[];
+//# sourceMappingURL=chainParamsRules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chainParamsRules.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/chainParamsRules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAAE,mBAAmB,EACjC,MAAM,iBAAiB,CAAA;AAKxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,qEAAqE;AACrE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAExG;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,MAAM,GACb,mBAAmB,CAErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAErF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,IAAI,EAAE,WAAW,EACjB,eAAe,EAAE,MAAM,GACtB,MAAM,EAAE,CAqBV"}

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

@@ -1,7 +1,12 @@
+export * from './admissionShadow.js';
 export * from './chainContractManifest.js';
 export * from './chainManifest.js';
+export * from './chainParams.js';
+export * from './chainParamsRules.js';
 export * from './evmEventIndex.js';
 export * from './indexManifest.js';
 export * from './networkStakeRewardsIndex.js';
+export * from './slashIndex.js';
 export * from './transactionInclusionIndex.js';
+export * from './trustedPosture.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gCAAgC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gCAAgC,CAAA;AAC9C,cAAc,qBAAqB,CAAA"}