@xyo-network/xl1-protocol 5.1.3 → 5.2.0

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,10 @@
 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 './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,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,gCAAgC,CAAA;AAC9C,cAAc,qBAAqB,CAAA"}

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/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"}