@xyo-network/xl1-protocol 5.1.3 → 5.2.0

package/dist/neutral/modules/protocol-model/rejection/BlockRejectionPayload.d.ts

@@ -14,6 +14,7 @@ export declare const BlockRejectionFieldsZod: z.ZodMiniObject<{
         previous: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         step_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;
@@ -54,6 +55,7 @@ export declare const BlockRejectionZod: z.ZodMiniObject<{
         previous: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         protocol: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         step_hashes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        supersedes: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
         schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
             readonly __schema: true;
         }>;
@@ -108,6 +110,7 @@ export declare const isBlockRejection: (x?: unknown) => x is {
         $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
         $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
             readonly __hex: true;
         } & {
@@ -149,6 +152,7 @@ export declare const asBlockRejection: import("@ariestools/sdk").AsTypeFunction<
         $signatures: (import("@ariestools/sdk").BrandedHex | null)[];
         protocol?: number | undefined;
         step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+        supersedes?: import("@ariestools/sdk").BrandedHash | undefined;
         $destination?: import("@xyo-network/sdk").XyoQuantAddress | (Lowercase<string> & {
             readonly __hex: true;
         } & {

package/dist/neutral/modules/protocol-model/rejection/BlockRejectionPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockRejectionPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/rejection/BlockRejectionPayload.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAgD,CAAA;AACjF,6DAA6D;AAC7D,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D,uEAAuE;AACvE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAA;AAEF,yDAAyD;AACzD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG7B,CAAA;AAED,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,qEAAqE;AACrE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8D,CAAA;AAE3F,uEAAuE;AACvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2C,CAAA"}
+{"version":3,"file":"BlockRejectionPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/rejection/BlockRejectionPayload.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAgD,CAAA;AACjF,6DAA6D;AAC7D,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D,uEAAuE;AACvE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAA;AAEF,yDAAyD;AACzD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG7B,CAAA;AAED,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,qEAAqE;AACrE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8D,CAAA;AAE3F,uEAAuE;AACvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2C,CAAA"}

package/dist/neutral/network-model.mjs

@@ -157,6 +157,8 @@ import { asHash } from "@ariestools/sdk";
 // src/modules/network-model/staticRest/paths/chainState.ts
 var headPath = () => "chain/head.json";
 var chainContractByIdPath = (chainId) => `chain/contracts/${chainId.toLowerCase()}.json`;
+var chainParamsVersionPath = (chainId, version) => `chain/params/${chainId.toLowerCase()}/v${version}.json`;
+var chainParamsHeadPath = (chainId) => `chain/params/${chainId.toLowerCase()}/head.json`;
 
 // src/modules/network-model/staticRest/paths/finalized.ts
 var manifestPath = () => "manifest.json";
@@ -260,98 +262,242 @@ function createChainManifest(encoding, earliestBlock = 0) {
   }, true);
 }
 
+// src/modules/network-model/staticRest/layout/chainParams.ts
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@ariestools/sdk";
+import { asSchema as asSchema2 } from "@xyo-network/sdk";
+import { z as z3 } from "zod";
+import { ChainIdZod as ChainIdZod2, NumberishZod as NumberishZod2 } from "#protocol-lib";
+import { OffenseCodes, RuleIds } from "#protocol-model";
+var ChainParamsSchema = asSchema2("network.xyo.s3.chain.params", true);
+var CHAIN_PARAMS_VERSION = 1;
+var offenseCodeZod = z3.enum(OffenseCodes);
+var RuleIdZod = z3.enum(RuleIds);
+var HeightZod = NumberishZod2.pipe(z3.int().nonnegative());
+var HexAmountZod = z3.string();
+var ChainParamsZod = z3.object({
+  /** Rule id to the height it takes effect. */
+  activations: z3.partialRecord(RuleIdZod, HeightZod),
+  /** Address whose adjudication records are honored. */
+  arbiter: z3.string(),
+  /** Share of a step's reward pool paid to attestors, in basis points. */
+  attestationRewardBps: z3.int().nonnegative(),
+  /** Absolute ceiling on any single bounty, in the smallest unit. */
+  bountyCapAtto: HexAmountZod,
+  /** Share of a slash offered as a bounty, in basis points. */
+  bountyShareBps: z3.int().nonnegative(),
+  /** Minimum share of every slash that must be burned, in basis points. */
+  burnFloorBps: z3.int().positive(),
+  /** Version of the offense catalog these parameters describe. */
+  catalogVersion: z3.int().positive(),
+  /** Chain these parameters govern. */
+  chainId: ChainIdZod2,
+  /** Window during which counter-evidence may be filed, in EVM blocks. */
+  challengeWindowEvmBlocks: z3.int().positive(),
+  /** Rule id to the height it stops taking effect; re-activation needs a later version. */
+  deactivations: z3.optional(z3.partialRecord(RuleIdZod, HeightZod)),
+  /** Maximum age of an offense at report time, in EVM blocks. */
+  evidenceFreshnessEvmBlocks: z3.int().positive(),
+  /** Operational floor on how long evidence is kept, in XL1 blocks. */
+  evidenceRetentionXl1Blocks: z3.int().positive(),
+  /** Delay between a certificate being queued and executable, in EVM blocks. */
+  executionDelayEvmBlocks: z3.int().positive(),
+  /** How far behind its own anchor a block's stake measurement may sit, in EVM blocks. */
+  freshnessBandEvmBlocks: z3.int().positive(),
+  /** Blocks after an activation during which the rule is observed but not enforced. */
+  graceBandXl1Blocks: z3.int().nonnegative(),
+  /** Confirmation depth an anchor must sit behind the EVM head, in EVM blocks. */
+  maturityEvmBlocks: z3.int().positive(),
+  /** Minimum stake a producer must place on itself, in the smallest unit. */
+  minProducerSelfBondAtto: HexAmountZod,
+  /** Minimum stake on a producer address, in the smallest unit. */
+  minProducerStakeAtto: HexAmountZod,
+  /** Minimum age stake must reach before it counts toward participation, in EVM blocks. */
+  minStakeAgeEvmBlocks: z3.int().nonnegative(),
+  /** Minimum stake a validator must hold, in the smallest unit. */
+  minValidatorStakeAtto: HexAmountZod,
+  /** Slack the timing budget carries for operations and stalls, in EVM blocks. */
+  opsAllowanceEvmBlocks: z3.int().positive(),
+  /** Lowest protocol version a block may declare. */
+  protocolMin: z3.int().positive(),
+  /** Refundable deposit a report must escrow, in the smallest unit. */
+  reporterDepositAtto: HexAmountZod,
+  /** Blocks a reveal must wait after its commitment. */
+  revealDelayEvmBlocks: z3.int().positive(),
+  /** Blocks a reveal must wait after its commitment, on the XL1 clock. */
+  revealDelayXl1Blocks: z3.int().positive(),
+  /** Blocks after which an unrevealed commitment expires. */
+  revealWindowEvmBlocks: z3.int().positive(),
+  /** Blocks after which an unrevealed commitment expires, on the XL1 clock. */
+  revealWindowXl1Blocks: z3.int().positive(),
+  /** Where the allowed block reward comes from. */
+  rewardSource: z3.enum(["schedule", "contract"]),
+  schema: z3.literal(ChainParamsSchema),
+  /** Offense code to the share of at-risk stake it slashes, in basis points. */
+  slashFractionsBps: z3.partialRecord(offenseCodeZod, z3.int().nonnegative()),
+  /** Distinct validator signatures a slash certificate needs. */
+  slashQuorumCount: z3.int().positive(),
+  /** Version of this register document. */
+  version: z3.int().positive()
+});
+var isChainParams = zodIsFactory3(ChainParamsZod);
+var asChainParams = zodAsFactory3(ChainParamsZod, "asChainParams");
+var toChainParams = zodToFactory3(ChainParamsZod, "toChainParams");
+var ChainParamsHeadSchema = asSchema2("network.xyo.s3.chain.params.head", true);
+var ChainParamsHeadZod = z3.object({
+  /** Hash of the version document, so a reader can tell it got the one the head meant. */
+  hash: z3.string(),
+  schema: z3.literal(ChainParamsHeadSchema),
+  /** Version number the pointer names. */
+  version: z3.int().positive()
+});
+var isChainParamsHead = zodIsFactory3(ChainParamsHeadZod);
+var asChainParamsHead = zodAsFactory3(ChainParamsHeadZod, "asChainParamsHead");
+function createChainParams(config) {
+  return ChainParamsZod.parse({ ...config, schema: ChainParamsSchema });
+}
+function createChainParamsHead(version, hash) {
+  return ChainParamsHeadZod.parse({
+    hash,
+    schema: ChainParamsHeadSchema,
+    version
+  });
+}
+
+// src/modules/network-model/staticRest/layout/chainParamsRules.ts
+import {
+  adjudicableRuleId,
+  isRuleObservedAt,
+  reportableRuleId,
+  ruleActivationStateAt
+} from "#protocol-model";
+function isOffenseReportableAt(params, offense, height) {
+  return isRuleObservedAt(params, reportableRuleId(offense), height);
+}
+function offenseAdjudicationStateAt(params, offense, height) {
+  return ruleActivationStateAt(params, adjudicableRuleId(offense), height);
+}
+function protocolMinAt(params, height) {
+  return isRuleObservedAt(params, "anchor-rules", height) ? params.protocolMin : void 0;
+}
+function chainParamsSuccessionErrors(previous, next, finalizedHeight) {
+  if (previous === void 0) return [];
+  const errors = [];
+  if (next.version <= previous.version) {
+    errors.push(`version must increase: ${previous.version} -> ${next.version}`);
+  }
+  if (next.chainId !== previous.chainId) {
+    errors.push(`chainId must not change: ${previous.chainId} -> ${next.chainId}`);
+  }
+  for (const [ruleId, height] of Object.entries(previous.activations)) {
+    if (height > finalizedHeight) continue;
+    if (next.activations[ruleId] !== height) {
+      errors.push(`activation for '${ruleId}' is already in force at ${height} and must not move`);
+    }
+  }
+  for (const [ruleId, height] of Object.entries(next.deactivations ?? {})) {
+    if (height < finalizedHeight) {
+      errors.push(`deactivation for '${ruleId}' at ${height} is in the past`);
+    }
+  }
+  return errors;
+}
+
 // src/modules/network-model/staticRest/layout/evmEventIndex.ts
 import {
   EthAddressZod,
   HexRegExMinMaxMixedCaseWithPrefix,
-  zodAsFactory as zodAsFactory3
+  zodAsFactory as zodAsFactory4
 } from "@ariestools/sdk";
-import { z as z3 } from "zod/mini";
-var EvmHashZod = z3.string().check(z3.regex(HexRegExMinMaxMixedCaseWithPrefix(32, 32)));
-var EvmDataZod = z3.string().check(z3.regex(/^0x[\dA-Fa-f]*$/));
-var EvmEventIndexLogZod = z3.object({
+import { z as z4 } from "zod/mini";
+var EvmHashZod = z4.string().check(z4.regex(HexRegExMinMaxMixedCaseWithPrefix(32, 32)));
+var EvmDataZod = z4.string().check(z4.regex(/^0x[\dA-Fa-f]*$/));
+var EvmEventIndexLogZod = z4.object({
   address: EthAddressZod,
   blockHash: EvmHashZod,
-  blockNumber: z3.number(),
+  blockNumber: z4.number(),
   data: EvmDataZod,
-  index: z3.number(),
-  topics: z3.array(EvmHashZod),
+  index: z4.number(),
+  topics: z4.array(EvmHashZod),
   transactionHash: EvmHashZod,
-  transactionIndex: z3.number()
+  transactionIndex: z4.number()
 });
-var EvmEventIndexFrameZod = z3.object({
-  fromBlock: z3.number(),
-  logs: z3.array(EvmEventIndexLogZod),
-  toBlock: z3.number()
+var EvmEventIndexFrameZod = z4.object({
+  fromBlock: z4.number(),
+  logs: z4.array(EvmEventIndexLogZod),
+  toBlock: z4.number()
 });
-var EvmEventIndexManifestZod = z3.object({
+var EvmEventIndexManifestZod = z4.object({
   address: EthAddressZod,
-  chainId: z3.string(),
-  deploymentBlock: z3.number(),
-  frameSize: z3.number(),
-  layout: z3.literal("evm-contract-events-v1")
+  chainId: z4.string(),
+  deploymentBlock: z4.number(),
+  frameSize: z4.number(),
+  layout: z4.literal("evm-contract-events-v1")
 });
-var EvmEventIndexHeadZod = z3.object({
+var EvmEventIndexHeadZod = z4.object({
   address: EthAddressZod,
-  block: z3.number(),
-  chainId: z3.string(),
+  block: z4.number(),
+  chainId: z4.string(),
   hash: EvmHashZod
 });
-var asEvmEventIndexFrame = zodAsFactory3(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
-var asEvmEventIndexHead = zodAsFactory3(EvmEventIndexHeadZod, "asEvmEventIndexHead");
-var asEvmEventIndexManifest = zodAsFactory3(EvmEventIndexManifestZod, "asEvmEventIndexManifest");
+var asEvmEventIndexFrame = zodAsFactory4(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
+var asEvmEventIndexHead = zodAsFactory4(EvmEventIndexHeadZod, "asEvmEventIndexHead");
+var asEvmEventIndexManifest = zodAsFactory4(EvmEventIndexManifestZod, "asEvmEventIndexManifest");
 
 // src/modules/network-model/staticRest/layout/indexManifest.ts
 import {
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory3
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory4
 } from "@ariestools/sdk";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var INDEX_LAYOUT_VERSION = 1;
 var IndexManifestSchema = "network.xyo.s3.index.manifest";
 var IndexHeadSchema = "network.xyo.s3.index.head";
-var IndexManifestFamilyZod = z4.object({
+var IndexManifestFamilyZod = z5.object({
   /** Highest step level published for this family. */
-  maxStep: z4.int().nonnegative(),
+  maxStep: z5.int().nonnegative(),
   /** Path template for the family's frames, e.g. `blocks/{level}/{index}.json`. */
-  path: z4.string()
+  path: z5.string()
 });
-var indexFamiliesZod = z4.object({
+var indexFamiliesZod = z5.object({
   balances: IndexManifestFamilyZod,
   blocks: IndexManifestFamilyZod,
   schemas: IndexManifestFamilyZod,
   transfers: IndexManifestFamilyZod
 });
-var IndexManifestZod = z4.object({
+var IndexManifestZod = z5.object({
   families: indexFamiliesZod,
-  schema: z4.literal(IndexManifestSchema),
-  version: z4.int().positive()
+  schema: z5.literal(IndexManifestSchema),
+  version: z5.int().positive()
 });
-var isIndexManifest = zodIsFactory3(IndexManifestZod);
-var asIndexManifest = zodAsFactory4(IndexManifestZod, "asIndexManifest");
-var toIndexManifest = zodToFactory3(IndexManifestZod, "toIndexManifest");
-var IndexHeadFamiliesZod = z4.object({
-  balances: z4.int().nonnegative(),
-  blocks: z4.int().nonnegative(),
-  schemas: z4.int().nonnegative(),
-  transfers: z4.int().nonnegative()
+var isIndexManifest = zodIsFactory4(IndexManifestZod);
+var asIndexManifest = zodAsFactory5(IndexManifestZod, "asIndexManifest");
+var toIndexManifest = zodToFactory4(IndexManifestZod, "toIndexManifest");
+var IndexHeadFamiliesZod = z5.object({
+  balances: z5.int().nonnegative(),
+  blocks: z5.int().nonnegative(),
+  schemas: z5.int().nonnegative(),
+  transfers: z5.int().nonnegative()
 });
-var IndexHeadZod = z4.object({
+var IndexHeadZod = z5.object({
   /** Highest block the index is complete through. */
-  block: z4.int().nonnegative(),
+  block: z5.int().nonnegative(),
   /** Completed frame counts per family. */
   families: IndexHeadFamiliesZod,
   /** Hash of that block. */
-  hash: z4.string(),
-  schema: z4.literal(IndexHeadSchema),
+  hash: z5.string(),
+  schema: z5.literal(IndexHeadSchema),
   /** ISO-8601 timestamp of the last update. */
-  updatedAt: z4.string(),
-  version: z4.int().positive()
+  updatedAt: z5.string(),
+  version: z5.int().positive()
 });
-var isIndexHead = zodIsFactory3(IndexHeadZod);
-var asIndexHead = zodAsFactory4(IndexHeadZod, "asIndexHead");
-var toIndexHead = zodToFactory3(IndexHeadZod, "toIndexHead");
+var isIndexHead = zodIsFactory4(IndexHeadZod);
+var asIndexHead = zodAsFactory5(IndexHeadZod, "asIndexHead");
+var toIndexHead = zodToFactory4(IndexHeadZod, "toIndexHead");
 function createIndexManifestFamilies(maxSteps) {
   return {
     balances: { maxStep: maxSteps.balances, path: indexSummaryPathTemplate("balances") },
@@ -383,84 +529,84 @@ function createIndexHead(watermark, updatedAt) {
 // src/modules/network-model/staticRest/layout/networkStakeRewardsIndex.ts
 import {
   HashZod,
-  zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory4
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory5
 } from "@ariestools/sdk";
-import { asSchema as asSchema2 } from "@xyo-network/sdk";
-import { z as z5 } from "zod";
+import { asSchema as asSchema3 } from "@xyo-network/sdk";
+import { z as z6 } from "zod";
 var NETWORK_STAKE_REWARDS_INDEX_LAYOUT = "network-stake-rewards-v1";
 var NETWORK_STAKE_REWARDS_UNMULTIPLIED_POLICY = "unmultiplied-v1";
 var NETWORK_STAKE_REWARDS_BASE_POLICY = NETWORK_STAKE_REWARDS_UNMULTIPLIED_POLICY;
-var NetworkStakeRewardsIndexSnapshotSchema = asSchema2("network.xyo.chain.stake.rewards.snapshot", true);
-var DecimalBigIntZod = z5.string().regex(/^(?:0|[1-9]\d*)$/);
-var NetworkStakeRewardsPolicyIdZod = z5.string().regex(/^[a-z0-9][a-z0-9._-]*$/);
-var PositionRewardsZod = z5.record(z5.string().regex(/^(?:0|[1-9]\d*)$/), DecimalBigIntZod);
-var BlockRangeZod = z5.tuple([z5.number().int().nonnegative(), z5.number().int().nonnegative()]);
-var StepIdentityJsonZod = z5.object({
-  block: z5.number().int().nonnegative(),
-  step: z5.number().int().nonnegative()
+var NetworkStakeRewardsIndexSnapshotSchema = asSchema3("network.xyo.chain.stake.rewards.snapshot", true);
+var DecimalBigIntZod = z6.string().regex(/^(?:0|[1-9]\d*)$/);
+var NetworkStakeRewardsPolicyIdZod = z6.string().regex(/^[a-z0-9][a-z0-9._-]*$/);
+var PositionRewardsZod = z6.record(z6.string().regex(/^(?:0|[1-9]\d*)$/), DecimalBigIntZod);
+var BlockRangeZod = z6.tuple([z6.number().int().nonnegative(), z6.number().int().nonnegative()]);
+var StepIdentityJsonZod = z6.object({
+  block: z6.number().int().nonnegative(),
+  step: z6.number().int().nonnegative()
 });
-var NetworkStakeRewardsIndexManifestZod = z5.object({
-  evmAddress: z5.string(),
-  evmChainId: z5.string(),
-  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+var NetworkStakeRewardsIndexManifestZod = z6.object({
+  evmAddress: z6.string(),
+  evmChainId: z6.string(),
+  layout: z6.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
   policyId: NetworkStakeRewardsPolicyIdZod,
-  stepLevels: z5.array(z5.number().int().nonnegative()),
-  timeAnchor: z5.object({
-    externalGenesisTime: z5.number().optional(),
-    maxScanBlocks: z5.number().optional()
+  stepLevels: z6.array(z6.number().int().nonnegative()),
+  timeAnchor: z6.object({
+    externalGenesisTime: z6.number().optional(),
+    maxScanBlocks: z6.number().optional()
   }).optional()
 });
-var NetworkStakeRewardsIndexStepZod = z5.object({
+var NetworkStakeRewardsIndexStepZod = z6.object({
   denominator: DecimalBigIntZod,
   externalRange: BlockRangeZod,
-  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+  layout: z6.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
   policyId: NetworkStakeRewardsPolicyIdZod,
   positionRewards: PositionRewardsZod,
   step: StepIdentityJsonZod,
   totalReward: DecimalBigIntZod,
   xl1Range: BlockRangeZod
 });
-var NetworkStakeRewardsIndexSnapshotZod = z5.object({
-  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+var NetworkStakeRewardsIndexSnapshotZod = z6.object({
+  layout: z6.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
   policyId: NetworkStakeRewardsPolicyIdZod,
   positionRewards: PositionRewardsZod,
-  schema: z5.literal(NetworkStakeRewardsIndexSnapshotSchema),
-  stepCount: z5.number().int().nonnegative(),
+  schema: z6.literal(NetworkStakeRewardsIndexSnapshotSchema),
+  stepCount: z6.number().int().nonnegative(),
   totalReward: DecimalBigIntZod
 });
-var NetworkStakeRewardsIndexHeadZod = z5.object({
-  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+var NetworkStakeRewardsIndexHeadZod = z6.object({
+  layout: z6.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
   policyId: NetworkStakeRewardsPolicyIdZod,
-  positionCount: z5.number().int().nonnegative(),
-  processedThroughBlock: z5.number().int().nonnegative(),
+  positionCount: z6.number().int().nonnegative(),
+  processedThroughBlock: z6.number().int().nonnegative(),
   snapshotHash: HashZod,
-  source: z5.object({
-    evm: z5.object({
-      block: z5.number().int().nonnegative(),
-      hash: z5.string()
+  source: z6.object({
+    evm: z6.object({
+      block: z6.number().int().nonnegative(),
+      hash: z6.string()
     }),
-    xl1: z5.object({
-      block: z5.number().int().nonnegative(),
-      hash: z5.string()
+    xl1: z6.object({
+      block: z6.number().int().nonnegative(),
+      hash: z6.string()
     })
   }),
-  stepCount: z5.number().int().nonnegative()
+  stepCount: z6.number().int().nonnegative()
 });
-var isNetworkStakeRewardsIndexManifest = zodIsFactory4(NetworkStakeRewardsIndexManifestZod);
-var asNetworkStakeRewardsIndexManifest = zodAsFactory5(
+var isNetworkStakeRewardsIndexManifest = zodIsFactory5(NetworkStakeRewardsIndexManifestZod);
+var asNetworkStakeRewardsIndexManifest = zodAsFactory6(
   NetworkStakeRewardsIndexManifestZod,
   "asNetworkStakeRewardsIndexManifest"
 );
-var asNetworkStakeRewardsIndexStep = zodAsFactory5(
+var asNetworkStakeRewardsIndexStep = zodAsFactory6(
   NetworkStakeRewardsIndexStepZod,
   "asNetworkStakeRewardsIndexStep"
 );
-var asNetworkStakeRewardsIndexSnapshot = zodAsFactory5(
+var asNetworkStakeRewardsIndexSnapshot = zodAsFactory6(
   NetworkStakeRewardsIndexSnapshotZod,
   "asNetworkStakeRewardsIndexSnapshot"
 );
-var asNetworkStakeRewardsIndexHead = zodAsFactory5(
+var asNetworkStakeRewardsIndexHead = zodAsFactory6(
   NetworkStakeRewardsIndexHeadZod,
   "asNetworkStakeRewardsIndexHead"
 );
@@ -468,48 +614,48 @@ var asNetworkStakeRewardsIndexHead = zodAsFactory5(
 // src/modules/network-model/staticRest/layout/transactionInclusionIndex.ts
 import {
   HashZod as HashZod2,
-  zodAsFactory as zodAsFactory6,
-  zodIsFactory as zodIsFactory5,
-  zodToFactory as zodToFactory4
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory5
 } from "@ariestools/sdk";
-import { z as z6 } from "zod";
-import { ChainIdZod as ChainIdZod2, XL1BlockNumberZod } from "#protocol-model";
+import { z as z7 } from "zod";
+import { ChainIdZod as ChainIdZod3, XL1BlockNumberZod } from "#protocol-model";
 var TRANSACTION_INCLUSION_INDEX_LAYOUT = "transaction-inclusions-v1";
-var TransactionInclusionManifestZod = z6.object({
+var TransactionInclusionManifestZod = z7.object({
   /** XL1 chain whose finalized transactions are indexed. */
-  chain: ChainIdZod2,
+  chain: ChainIdZod3,
   /** Versioned layout identifier. */
-  layout: z6.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT),
+  layout: z7.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT),
   /** Hash-addressed path template, for example `transactions/by-hash/{hash}.json`. */
-  path: z6.string()
+  path: z7.string()
 });
-var TransactionInclusionHeadZod = z6.object({
+var TransactionInclusionHeadZod = z7.object({
   /** Highest finalized block fully represented by the lookup. */
   block: XL1BlockNumberZod,
   /** Hash of the highest finalized block fully represented by the lookup. */
   blockHash: HashZod2,
   /** XL1 chain whose finalized transactions are indexed. */
-  chain: ChainIdZod2,
+  chain: ChainIdZod3,
   /** Number of transaction-inclusion records represented through `block`. */
-  entries: z6.int().nonnegative(),
+  entries: z7.int().nonnegative(),
   /** Versioned layout identifier. */
-  layout: z6.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT)
+  layout: z7.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT)
 });
-var isTransactionInclusionManifest = zodIsFactory5(TransactionInclusionManifestZod);
-var asTransactionInclusionManifest = zodAsFactory6(
+var isTransactionInclusionManifest = zodIsFactory6(TransactionInclusionManifestZod);
+var asTransactionInclusionManifest = zodAsFactory7(
   TransactionInclusionManifestZod,
   "asTransactionInclusionManifest"
 );
-var toTransactionInclusionManifest = zodToFactory4(
+var toTransactionInclusionManifest = zodToFactory5(
   TransactionInclusionManifestZod,
   "toTransactionInclusionManifest"
 );
-var isTransactionInclusionHead = zodIsFactory5(TransactionInclusionHeadZod);
-var asTransactionInclusionHead = zodAsFactory6(
+var isTransactionInclusionHead = zodIsFactory6(TransactionInclusionHeadZod);
+var asTransactionInclusionHead = zodAsFactory7(
   TransactionInclusionHeadZod,
   "asTransactionInclusionHead"
 );
-var toTransactionInclusionHead = zodToFactory4(
+var toTransactionInclusionHead = zodToFactory5(
   TransactionInclusionHeadZod,
   "toTransactionInclusionHead"
 );
@@ -527,6 +673,53 @@ function createTransactionInclusionHead(head) {
   }, true);
 }
 
+// src/modules/network-model/staticRest/layout/trustedPosture.ts
+var DEFAULT_CHAIN_PARAMS = {
+  attestationRewardBps: 1e3,
+  bountyShareBps: 1e3,
+  burnFloorBps: 9e3,
+  catalogVersion: 1,
+  challengeWindowEvmBlocks: 14400,
+  evidenceFreshnessEvmBlocks: 21600,
+  evidenceRetentionXl1Blocks: 6e4,
+  executionDelayEvmBlocks: 7200,
+  freshnessBandEvmBlocks: 2048,
+  graceBandXl1Blocks: 1440,
+  maturityEvmBlocks: 32,
+  minStakeAgeEvmBlocks: 100800,
+  opsAllowanceEvmBlocks: 7200,
+  protocolMin: 1003e3,
+  revealDelayEvmBlocks: 60,
+  revealDelayXl1Blocks: 10,
+  revealWindowEvmBlocks: 7200,
+  revealWindowXl1Blocks: 1440,
+  slashFractionsBps: {
+    "equivocation": 1500,
+    "false-anchor": 750,
+    "false-attestation": 500,
+    "ineligible-production": 100,
+    "invalid-block": 500,
+    "invalid-slash-request": 750,
+    "reward-overmint": 1500
+  },
+  slashQuorumCount: 5
+};
+function createTrustedPostureParams(config) {
+  return createChainParams({
+    ...DEFAULT_CHAIN_PARAMS,
+    activations: {},
+    arbiter: config.arbiter,
+    bountyCapAtto: config.bountyCapAtto ?? "00",
+    chainId: config.chainId,
+    minProducerSelfBondAtto: config.minProducerSelfBondAtto ?? "00",
+    minProducerStakeAtto: config.minProducerStakeAtto ?? "00",
+    minValidatorStakeAtto: config.minValidatorStakeAtto ?? "00",
+    reporterDepositAtto: config.reporterDepositAtto ?? "00",
+    rewardSource: config.rewardSource ?? "contract",
+    version: config.version ?? 1
+  });
+}
+
 // src/modules/network-model/staticRest/paths/evmEventIndex.ts
 function root(address) {
   return `evm/events/${address.toLowerCase()}`;
@@ -623,11 +816,17 @@ var ExplorerLinks = class {
 export {
   CHAIN_CONTRACT_MANIFEST_VERSION,
   CHAIN_LAYOUT_VERSION,
+  CHAIN_PARAMS_VERSION,
   ChainContractManifestSchema,
   ChainContractManifestZod,
   ChainManifestPathsZod,
   ChainManifestSchema,
   ChainManifestZod,
+  ChainParamsHeadSchema,
+  ChainParamsHeadZod,
+  ChainParamsSchema,
+  ChainParamsZod,
+  DEFAULT_CHAIN_PARAMS,
   DefaultNetworks,
   EvmEventIndexFrameZod,
   EvmEventIndexHeadZod,
@@ -656,6 +855,7 @@ export {
   NetworkStakeRewardsIndexSnapshotZod,
   NetworkStakeRewardsIndexStepZod,
   NetworkStakeRewardsPolicyIdZod,
+  RuleIdZod,
   SequenceNetwork,
   testnet_default as SequenceNetworkIconString,
   TRANSACTION_INCLUSION_INDEX_LAYOUT,
@@ -663,6 +863,8 @@ export {
   TransactionInclusionManifestZod,
   asChainContractManifest,
   asChainManifest,
+  asChainParams,
+  asChainParamsHead,
   asEvmEventIndexFrame,
   asEvmEventIndexHead,
   asEvmEventIndexManifest,
@@ -681,13 +883,19 @@ export {
   blockNumberPathTemplate,
   chainContractByIdPath,
   chainManifestPathTemplates,
+  chainParamsHeadPath,
+  chainParamsSuccessionErrors,
+  chainParamsVersionPath,
   createChainContractManifest,
   createChainManifest,
+  createChainParams,
+  createChainParamsHead,
   createIndexHead,
   createIndexManifest,
   createIndexManifestFamilies,
   createTransactionInclusionHead,
   createTransactionInclusionManifest,
+  createTrustedPostureParams,
   evmEventIndexFramePath,
   evmEventIndexHeadPath,
   evmEventIndexManifestPath,
@@ -703,10 +911,13 @@ export {
   interpolatePathTemplate,
   isChainContractManifest,
   isChainManifest,
+  isChainParams,
+  isChainParamsHead,
   isIndexHead,
   isIndexManifest,
   isNetworkBootstrap,
   isNetworkStakeRewardsIndexManifest,
+  isOffenseReportableAt,
   isTransactionInclusionHead,
   isTransactionInclusionManifest,
   manifestPath,
@@ -714,10 +925,13 @@ export {
   networkStakeRewardsIndexManifestPath,
   networkStakeRewardsIndexSnapshotPath,
   networkStakeRewardsIndexStepPath,
+  offenseAdjudicationStateAt,
   payloadPath,
   payloadPathTemplate,
+  protocolMinAt,
   toChainContractManifest,
   toChainManifest,
+  toChainParams,
   toIndexHead,
   toIndexManifest,
   toPathTemplate,