@xyo-network/xl1-protocol 5.1.4 → 5.2.1

package/dist/neutral/network-model.mjs

@@ -106,34 +106,80 @@ var initNetworkNode = async (activeNetwork, wallet) => {
   return activeNetworkNode;
 };
 
+// src/modules/network-model/staticRest/layout/admissionShadow.ts
+import { zodAsFactory, zodIsFactory } from "@ariestools/sdk";
+import { asSchema as asSchema2 } from "@xyo-network/sdk";
+import { z } from "zod";
+var AdmissionShadowReportSchema = asSchema2("network.xyo.s3.admission.shadow", true);
+var AdmissionShadowAssessmentZod = z.object({
+  /** Whether the allow-list admits it. */
+  admittedByAllowList: z.boolean(),
+  /** The candidate's height. */
+  block: z.int().nonnegative(),
+  /** The candidate's signed identity. */
+  dataHash: z.string(),
+  /** The EVM height stake was measured at, when it could be. */
+  eStar: z.optional(z.int().nonnegative()),
+  /** Whether participation admits it, when that could be established. */
+  eligible: z.optional(z.boolean()),
+  /** The producer. */
+  producer: z.string(),
+  /** Why participation refused, when it did. */
+  reason: z.optional(z.string()),
+  /** False when the participation question could not be put at all. */
+  resolvable: z.boolean()
+});
+var AdmissionShadowReportZod = z.object({
+  /** Every candidate considered this round. */
+  assessments: z.array(AdmissionShadowAssessmentZod),
+  /** Only those where the two gates disagreed. */
+  divergent: z.array(AdmissionShadowAssessmentZod),
+  /** The finalized height this round was selected against. */
+  head: z.int().nonnegative(),
+  /** Height of the previous published report, so the series can be walked backwards. */
+  previous: z.optional(z.int().nonnegative()),
+  schema: z.literal(AdmissionShadowReportSchema)
+});
+var isAdmissionShadowReport = zodIsFactory(AdmissionShadowReportZod);
+var asAdmissionShadowReport = zodAsFactory(AdmissionShadowReportZod, "asAdmissionShadowReport");
+function createAdmissionShadowReport(head, assessments, divergent, previous) {
+  return AdmissionShadowReportZod.parse({
+    assessments,
+    divergent,
+    head,
+    previous,
+    schema: AdmissionShadowReportSchema
+  });
+}
+
 // src/modules/network-model/staticRest/layout/chainContractManifest.ts
 import {
-  zodAsFactory,
-  zodIsFactory,
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
   zodToFactory
 } from "@ariestools/sdk";
-import { z } from "zod";
+import { z as z2 } from "zod";
 import {
   ChainIdZod,
   NumberishZod
 } from "#protocol-lib";
-var ChainContractBlockNumberZod = NumberishZod.pipe(z.int().nonnegative()).transform((value) => value);
+var ChainContractBlockNumberZod = NumberishZod.pipe(z2.int().nonnegative()).transform((value) => value);
 var ChainContractManifestSchema = "network.xyo.s3.chain.contract";
 var CHAIN_CONTRACT_MANIFEST_VERSION = 1;
-var ChainContractManifestZod = z.object({
+var ChainContractManifestZod = z2.object({
   /** Self-identifying chain id (matches the path key). Optional for older fixtures. */
-  chainId: z.optional(ChainIdZod),
+  chainId: z2.optional(ChainIdZod),
   forkedAtBlockNumber: ChainContractBlockNumberZod.nullable().optional(),
-  forkedAtHash: z.string().nullable().optional(),
-  forkedChainId: z.nullable(ChainIdZod).optional(),
-  minWithdrawalBlocks: NumberishZod.pipe(z.int().nonnegative()),
-  rewardsContract: z.string(),
-  schema: z.literal(ChainContractManifestSchema),
-  stakingTokenAddress: z.string(),
-  version: z.int().positive()
+  forkedAtHash: z2.string().nullable().optional(),
+  forkedChainId: z2.nullable(ChainIdZod).optional(),
+  minWithdrawalBlocks: NumberishZod.pipe(z2.int().nonnegative()),
+  rewardsContract: z2.string(),
+  schema: z2.literal(ChainContractManifestSchema),
+  stakingTokenAddress: z2.string(),
+  version: z2.int().positive()
 });
-var isChainContractManifest = zodIsFactory(ChainContractManifestZod);
-var asChainContractManifest = zodAsFactory(ChainContractManifestZod, "asChainContractManifest");
+var isChainContractManifest = zodIsFactory2(ChainContractManifestZod);
+var asChainContractManifest = zodAsFactory2(ChainContractManifestZod, "asChainContractManifest");
 var toChainContractManifest = zodToFactory(ChainContractManifestZod, "toChainContractManifest");
 function createChainContractManifest(config) {
   return ChainContractManifestZod.parse({
@@ -145,11 +191,11 @@ function createChainContractManifest(config) {
 
 // src/modules/network-model/staticRest/layout/chainManifest.ts
 import {
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory as zodIsFactory2,
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory2
 } from "@ariestools/sdk";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/modules/network-model/staticRest/templates.ts
 import { asHash } from "@ariestools/sdk";
@@ -157,6 +203,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";
@@ -232,23 +280,23 @@ function transactionInclusionPathTemplate() {
 // src/modules/network-model/staticRest/layout/chainManifest.ts
 var CHAIN_LAYOUT_VERSION = 1;
 var ChainManifestSchema = "network.xyo.s3.chain.manifest";
-var ChainManifestPathsZod = z2.object({
-  blockByHash: z2.string(),
-  blockByNumber: z2.string(),
-  head: z2.string(),
-  payload: z2.string()
+var ChainManifestPathsZod = z3.object({
+  blockByHash: z3.string(),
+  blockByNumber: z3.string(),
+  head: z3.string(),
+  payload: z3.string()
 });
-var ChainManifestZod = z2.object({
+var ChainManifestZod = z3.object({
   /** Lowest block number available in the bucket (genesis until pruning exists). */
-  earliestBlock: z2.int().nonnegative(),
+  earliestBlock: z3.int().nonnegative(),
   /** Storage/wire encoding of the published files (also on each object's Content-Encoding). */
-  encoding: z2.string(),
+  encoding: z3.string(),
   paths: ChainManifestPathsZod,
-  schema: z2.literal(ChainManifestSchema),
-  version: z2.int().positive()
+  schema: z3.literal(ChainManifestSchema),
+  version: z3.int().positive()
 });
-var isChainManifest = zodIsFactory2(ChainManifestZod);
-var asChainManifest = zodAsFactory2(ChainManifestZod, "asChainManifest");
+var isChainManifest = zodIsFactory3(ChainManifestZod);
+var asChainManifest = zodAsFactory3(ChainManifestZod, "asChainManifest");
 var toChainManifest = zodToFactory2(ChainManifestZod, "toChainManifest");
 function createChainManifest(encoding, earliestBlock = 0) {
   return asChainManifest({
@@ -260,98 +308,242 @@ function createChainManifest(encoding, earliestBlock = 0) {
   }, true);
 }
 
+// src/modules/network-model/staticRest/layout/chainParams.ts
+import {
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory3
+} from "@ariestools/sdk";
+import { asSchema as asSchema3 } from "@xyo-network/sdk";
+import { z as z4 } from "zod";
+import { ChainIdZod as ChainIdZod2, NumberishZod as NumberishZod2 } from "#protocol-lib";
+import { OffenseCodes, RuleIds } from "#protocol-model";
+var ChainParamsSchema = asSchema3("network.xyo.s3.chain.params", true);
+var CHAIN_PARAMS_VERSION = 1;
+var offenseCodeZod = z4.enum(OffenseCodes);
+var RuleIdZod = z4.enum(RuleIds);
+var HeightZod = NumberishZod2.pipe(z4.int().nonnegative());
+var HexAmountZod = z4.string();
+var ChainParamsZod = z4.object({
+  /** Rule id to the height it takes effect. */
+  activations: z4.partialRecord(RuleIdZod, HeightZod),
+  /** Address whose adjudication records are honored. */
+  arbiter: z4.string(),
+  /** Share of a step's reward pool paid to attestors, in basis points. */
+  attestationRewardBps: z4.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: z4.int().nonnegative(),
+  /** Minimum share of every slash that must be burned, in basis points. */
+  burnFloorBps: z4.int().positive(),
+  /** Version of the offense catalog these parameters describe. */
+  catalogVersion: z4.int().positive(),
+  /** Chain these parameters govern. */
+  chainId: ChainIdZod2,
+  /** Window during which counter-evidence may be filed, in EVM blocks. */
+  challengeWindowEvmBlocks: z4.int().positive(),
+  /** Rule id to the height it stops taking effect; re-activation needs a later version. */
+  deactivations: z4.optional(z4.partialRecord(RuleIdZod, HeightZod)),
+  /** Maximum age of an offense at report time, in EVM blocks. */
+  evidenceFreshnessEvmBlocks: z4.int().positive(),
+  /** Operational floor on how long evidence is kept, in XL1 blocks. */
+  evidenceRetentionXl1Blocks: z4.int().positive(),
+  /** Delay between a certificate being queued and executable, in EVM blocks. */
+  executionDelayEvmBlocks: z4.int().positive(),
+  /** How far behind its own anchor a block's stake measurement may sit, in EVM blocks. */
+  freshnessBandEvmBlocks: z4.int().positive(),
+  /** Blocks after an activation during which the rule is observed but not enforced. */
+  graceBandXl1Blocks: z4.int().nonnegative(),
+  /** Confirmation depth an anchor must sit behind the EVM head, in EVM blocks. */
+  maturityEvmBlocks: z4.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: z4.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: z4.int().positive(),
+  /** Lowest protocol version a block may declare. */
+  protocolMin: z4.int().positive(),
+  /** Refundable deposit a report must escrow, in the smallest unit. */
+  reporterDepositAtto: HexAmountZod,
+  /** Blocks a reveal must wait after its commitment. */
+  revealDelayEvmBlocks: z4.int().positive(),
+  /** Blocks a reveal must wait after its commitment, on the XL1 clock. */
+  revealDelayXl1Blocks: z4.int().positive(),
+  /** Blocks after which an unrevealed commitment expires. */
+  revealWindowEvmBlocks: z4.int().positive(),
+  /** Blocks after which an unrevealed commitment expires, on the XL1 clock. */
+  revealWindowXl1Blocks: z4.int().positive(),
+  /** Where the allowed block reward comes from. */
+  rewardSource: z4.enum(["schedule", "contract"]),
+  schema: z4.literal(ChainParamsSchema),
+  /** Offense code to the share of at-risk stake it slashes, in basis points. */
+  slashFractionsBps: z4.partialRecord(offenseCodeZod, z4.int().nonnegative()),
+  /** Distinct validator signatures a slash certificate needs. */
+  slashQuorumCount: z4.int().positive(),
+  /** Version of this register document. */
+  version: z4.int().positive()
+});
+var isChainParams = zodIsFactory4(ChainParamsZod);
+var asChainParams = zodAsFactory4(ChainParamsZod, "asChainParams");
+var toChainParams = zodToFactory3(ChainParamsZod, "toChainParams");
+var ChainParamsHeadSchema = asSchema3("network.xyo.s3.chain.params.head", true);
+var ChainParamsHeadZod = z4.object({
+  /** Hash of the version document, so a reader can tell it got the one the head meant. */
+  hash: z4.string(),
+  schema: z4.literal(ChainParamsHeadSchema),
+  /** Version number the pointer names. */
+  version: z4.int().positive()
+});
+var isChainParamsHead = zodIsFactory4(ChainParamsHeadZod);
+var asChainParamsHead = zodAsFactory4(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 zodAsFactory5
 } 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 z5 } from "zod/mini";
+var EvmHashZod = z5.string().check(z5.regex(HexRegExMinMaxMixedCaseWithPrefix(32, 32)));
+var EvmDataZod = z5.string().check(z5.regex(/^0x[\dA-Fa-f]*$/));
+var EvmEventIndexLogZod = z5.object({
   address: EthAddressZod,
   blockHash: EvmHashZod,
-  blockNumber: z3.number(),
+  blockNumber: z5.number(),
   data: EvmDataZod,
-  index: z3.number(),
-  topics: z3.array(EvmHashZod),
+  index: z5.number(),
+  topics: z5.array(EvmHashZod),
   transactionHash: EvmHashZod,
-  transactionIndex: z3.number()
+  transactionIndex: z5.number()
 });
-var EvmEventIndexFrameZod = z3.object({
-  fromBlock: z3.number(),
-  logs: z3.array(EvmEventIndexLogZod),
-  toBlock: z3.number()
+var EvmEventIndexFrameZod = z5.object({
+  fromBlock: z5.number(),
+  logs: z5.array(EvmEventIndexLogZod),
+  toBlock: z5.number()
 });
-var EvmEventIndexManifestZod = z3.object({
+var EvmEventIndexManifestZod = z5.object({
   address: EthAddressZod,
-  chainId: z3.string(),
-  deploymentBlock: z3.number(),
-  frameSize: z3.number(),
-  layout: z3.literal("evm-contract-events-v1")
+  chainId: z5.string(),
+  deploymentBlock: z5.number(),
+  frameSize: z5.number(),
+  layout: z5.literal("evm-contract-events-v1")
 });
-var EvmEventIndexHeadZod = z3.object({
+var EvmEventIndexHeadZod = z5.object({
   address: EthAddressZod,
-  block: z3.number(),
-  chainId: z3.string(),
+  block: z5.number(),
+  chainId: z5.string(),
   hash: EvmHashZod
 });
-var asEvmEventIndexFrame = zodAsFactory3(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
-var asEvmEventIndexHead = zodAsFactory3(EvmEventIndexHeadZod, "asEvmEventIndexHead");
-var asEvmEventIndexManifest = zodAsFactory3(EvmEventIndexManifestZod, "asEvmEventIndexManifest");
+var asEvmEventIndexFrame = zodAsFactory5(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
+var asEvmEventIndexHead = zodAsFactory5(EvmEventIndexHeadZod, "asEvmEventIndexHead");
+var asEvmEventIndexManifest = zodAsFactory5(EvmEventIndexManifestZod, "asEvmEventIndexManifest");
 
 // src/modules/network-model/staticRest/layout/indexManifest.ts
 import {
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory3
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory4
 } from "@ariestools/sdk";
-import { z as z4 } from "zod";
+import { z as z6 } 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 = z6.object({
   /** Highest step level published for this family. */
-  maxStep: z4.int().nonnegative(),
+  maxStep: z6.int().nonnegative(),
   /** Path template for the family's frames, e.g. `blocks/{level}/{index}.json`. */
-  path: z4.string()
+  path: z6.string()
 });
-var indexFamiliesZod = z4.object({
+var indexFamiliesZod = z6.object({
   balances: IndexManifestFamilyZod,
   blocks: IndexManifestFamilyZod,
   schemas: IndexManifestFamilyZod,
   transfers: IndexManifestFamilyZod
 });
-var IndexManifestZod = z4.object({
+var IndexManifestZod = z6.object({
   families: indexFamiliesZod,
-  schema: z4.literal(IndexManifestSchema),
-  version: z4.int().positive()
+  schema: z6.literal(IndexManifestSchema),
+  version: z6.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 = zodIsFactory5(IndexManifestZod);
+var asIndexManifest = zodAsFactory6(IndexManifestZod, "asIndexManifest");
+var toIndexManifest = zodToFactory4(IndexManifestZod, "toIndexManifest");
+var IndexHeadFamiliesZod = z6.object({
+  balances: z6.int().nonnegative(),
+  blocks: z6.int().nonnegative(),
+  schemas: z6.int().nonnegative(),
+  transfers: z6.int().nonnegative()
 });
-var IndexHeadZod = z4.object({
+var IndexHeadZod = z6.object({
   /** Highest block the index is complete through. */
-  block: z4.int().nonnegative(),
+  block: z6.int().nonnegative(),
   /** Completed frame counts per family. */
   families: IndexHeadFamiliesZod,
   /** Hash of that block. */
-  hash: z4.string(),
-  schema: z4.literal(IndexHeadSchema),
+  hash: z6.string(),
+  schema: z6.literal(IndexHeadSchema),
   /** ISO-8601 timestamp of the last update. */
-  updatedAt: z4.string(),
-  version: z4.int().positive()
+  updatedAt: z6.string(),
+  version: z6.int().positive()
 });
-var isIndexHead = zodIsFactory3(IndexHeadZod);
-var asIndexHead = zodAsFactory4(IndexHeadZod, "asIndexHead");
-var toIndexHead = zodToFactory3(IndexHeadZod, "toIndexHead");
+var isIndexHead = zodIsFactory5(IndexHeadZod);
+var asIndexHead = zodAsFactory6(IndexHeadZod, "asIndexHead");
+var toIndexHead = zodToFactory4(IndexHeadZod, "toIndexHead");
 function createIndexManifestFamilies(maxSteps) {
   return {
     balances: { maxStep: maxSteps.balances, path: indexSummaryPathTemplate("balances") },
@@ -383,133 +575,188 @@ function createIndexHead(watermark, updatedAt) {
 // src/modules/network-model/staticRest/layout/networkStakeRewardsIndex.ts
 import {
   HashZod,
-  zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory4
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory6
 } from "@ariestools/sdk";
-import { asSchema as asSchema2 } from "@xyo-network/sdk";
-import { z as z5 } from "zod";
+import { asSchema as asSchema4 } from "@xyo-network/sdk";
+import { z as z7 } 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 = asSchema4("network.xyo.chain.stake.rewards.snapshot", true);
+var DecimalBigIntZod = z7.string().regex(/^(?:0|[1-9]\d*)$/);
+var NetworkStakeRewardsPolicyIdZod = z7.string().regex(/^[a-z0-9][a-z0-9._-]*$/);
+var PositionRewardsZod = z7.record(z7.string().regex(/^(?:0|[1-9]\d*)$/), DecimalBigIntZod);
+var BlockRangeZod = z7.tuple([z7.number().int().nonnegative(), z7.number().int().nonnegative()]);
+var StepIdentityJsonZod = z7.object({
+  block: z7.number().int().nonnegative(),
+  step: z7.number().int().nonnegative()
 });
-var NetworkStakeRewardsIndexManifestZod = z5.object({
-  evmAddress: z5.string(),
-  evmChainId: z5.string(),
-  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+var NetworkStakeRewardsIndexManifestZod = z7.object({
+  evmAddress: z7.string(),
+  evmChainId: z7.string(),
+  layout: z7.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: z7.array(z7.number().int().nonnegative()),
+  timeAnchor: z7.object({
+    externalGenesisTime: z7.number().optional(),
+    maxScanBlocks: z7.number().optional()
   }).optional()
 });
-var NetworkStakeRewardsIndexStepZod = z5.object({
+var NetworkStakeRewardsIndexStepZod = z7.object({
   denominator: DecimalBigIntZod,
   externalRange: BlockRangeZod,
-  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+  layout: z7.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 = z7.object({
+  layout: z7.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
   policyId: NetworkStakeRewardsPolicyIdZod,
   positionRewards: PositionRewardsZod,
-  schema: z5.literal(NetworkStakeRewardsIndexSnapshotSchema),
-  stepCount: z5.number().int().nonnegative(),
+  schema: z7.literal(NetworkStakeRewardsIndexSnapshotSchema),
+  stepCount: z7.number().int().nonnegative(),
   totalReward: DecimalBigIntZod
 });
-var NetworkStakeRewardsIndexHeadZod = z5.object({
-  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+var NetworkStakeRewardsIndexHeadZod = z7.object({
+  layout: z7.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
   policyId: NetworkStakeRewardsPolicyIdZod,
-  positionCount: z5.number().int().nonnegative(),
-  processedThroughBlock: z5.number().int().nonnegative(),
+  positionCount: z7.number().int().nonnegative(),
+  processedThroughBlock: z7.number().int().nonnegative(),
   snapshotHash: HashZod,
-  source: z5.object({
-    evm: z5.object({
-      block: z5.number().int().nonnegative(),
-      hash: z5.string()
+  source: z7.object({
+    evm: z7.object({
+      block: z7.number().int().nonnegative(),
+      hash: z7.string()
     }),
-    xl1: z5.object({
-      block: z5.number().int().nonnegative(),
-      hash: z5.string()
+    xl1: z7.object({
+      block: z7.number().int().nonnegative(),
+      hash: z7.string()
     })
   }),
-  stepCount: z5.number().int().nonnegative()
+  stepCount: z7.number().int().nonnegative()
 });
-var isNetworkStakeRewardsIndexManifest = zodIsFactory4(NetworkStakeRewardsIndexManifestZod);
-var asNetworkStakeRewardsIndexManifest = zodAsFactory5(
+var isNetworkStakeRewardsIndexManifest = zodIsFactory6(NetworkStakeRewardsIndexManifestZod);
+var asNetworkStakeRewardsIndexManifest = zodAsFactory7(
   NetworkStakeRewardsIndexManifestZod,
   "asNetworkStakeRewardsIndexManifest"
 );
-var asNetworkStakeRewardsIndexStep = zodAsFactory5(
+var asNetworkStakeRewardsIndexStep = zodAsFactory7(
   NetworkStakeRewardsIndexStepZod,
   "asNetworkStakeRewardsIndexStep"
 );
-var asNetworkStakeRewardsIndexSnapshot = zodAsFactory5(
+var asNetworkStakeRewardsIndexSnapshot = zodAsFactory7(
   NetworkStakeRewardsIndexSnapshotZod,
   "asNetworkStakeRewardsIndexSnapshot"
 );
-var asNetworkStakeRewardsIndexHead = zodAsFactory5(
+var asNetworkStakeRewardsIndexHead = zodAsFactory7(
   NetworkStakeRewardsIndexHeadZod,
   "asNetworkStakeRewardsIndexHead"
 );
 
+// src/modules/network-model/staticRest/layout/slashIndex.ts
+import {
+  zodAsFactory as zodAsFactory8,
+  zodIsFactory as zodIsFactory7,
+  zodToFactory as zodToFactory5
+} from "@ariestools/sdk";
+import { asSchema as asSchema5 } from "@xyo-network/sdk";
+import { z as z8 } from "zod";
+import { OffenseCodes as OffenseCodes2 } from "#protocol-model";
+var SlashIndexHeadSchema = asSchema5("network.xyo.s3.slash.index.head", true);
+var SLASH_INDEX_VERSION = 1;
+var offenseCodeZod2 = z8.enum(OffenseCodes2);
+var SlashIndexHeadZod = z8.object({
+  /** Highest finalized height the index has folded in. */
+  height: z8.int().nonnegative(),
+  /** Layout version of the objects this head points at. */
+  indexVersion: z8.int().positive(),
+  schema: z8.literal(SlashIndexHeadSchema),
+  /** When the pass that wrote this ran, on the EVM clock, when it was known. */
+  anchor: z8.optional(z8.int().nonnegative())
+});
+var isSlashIndexHead = zodIsFactory7(SlashIndexHeadZod);
+var asSlashIndexHead = zodAsFactory8(SlashIndexHeadZod, "asSlashIndexHead");
+var toSlashIndexHead = zodToFactory5(SlashIndexHeadZod, "toSlashIndexHead");
+var SlashIndexKeyRecordSchema = asSchema5("network.xyo.s3.slash.index.key", true);
+var SlashIndexKeyRecordZod = z8.object({
+  /** Who is accused. */
+  accused: z8.string(),
+  /** Hash of the adjudication that closed it, when one has. */
+  adjudication: z8.optional(z8.string()),
+  /** The canonical height the offense is located at. */
+  block: z8.int().nonnegative(),
+  /** Hashes of challenges filed against reports of it. */
+  challenges: z8.array(z8.string()),
+  /** The chain it happened on. */
+  chain: z8.string(),
+  /** How it was resolved, when it has been. */
+  outcome: z8.optional(z8.enum(["confirmed", "refuted", "indeterminate", "invalid"])),
+  /** Which offense class. */
+  offense: offenseCodeZod2,
+  /** Hashes of every report filed for it, earliest first. */
+  requests: z8.array(z8.string()),
+  schema: z8.literal(SlashIndexKeyRecordSchema)
+});
+var isSlashIndexKeyRecord = zodIsFactory7(SlashIndexKeyRecordZod);
+var asSlashIndexKeyRecord = zodAsFactory8(SlashIndexKeyRecordZod, "asSlashIndexKeyRecord");
+function createSlashIndexHead(height, anchor) {
+  return SlashIndexHeadZod.parse({
+    anchor,
+    height,
+    indexVersion: SLASH_INDEX_VERSION,
+    schema: SlashIndexHeadSchema
+  });
+}
+
 // src/modules/network-model/staticRest/layout/transactionInclusionIndex.ts
 import {
   HashZod as HashZod2,
-  zodAsFactory as zodAsFactory6,
-  zodIsFactory as zodIsFactory5,
-  zodToFactory as zodToFactory4
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory8,
+  zodToFactory as zodToFactory6
 } from "@ariestools/sdk";
-import { z as z6 } from "zod";
-import { ChainIdZod as ChainIdZod2, XL1BlockNumberZod } from "#protocol-model";
+import { z as z9 } from "zod";
+import { ChainIdZod as ChainIdZod3, XL1BlockNumberZod } from "#protocol-model";
 var TRANSACTION_INCLUSION_INDEX_LAYOUT = "transaction-inclusions-v1";
-var TransactionInclusionManifestZod = z6.object({
+var TransactionInclusionManifestZod = z9.object({
   /** XL1 chain whose finalized transactions are indexed. */
-  chain: ChainIdZod2,
+  chain: ChainIdZod3,
   /** Versioned layout identifier. */
-  layout: z6.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT),
+  layout: z9.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT),
   /** Hash-addressed path template, for example `transactions/by-hash/{hash}.json`. */
-  path: z6.string()
+  path: z9.string()
 });
-var TransactionInclusionHeadZod = z6.object({
+var TransactionInclusionHeadZod = z9.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: z9.int().nonnegative(),
   /** Versioned layout identifier. */
-  layout: z6.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT)
+  layout: z9.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT)
 });
-var isTransactionInclusionManifest = zodIsFactory5(TransactionInclusionManifestZod);
-var asTransactionInclusionManifest = zodAsFactory6(
+var isTransactionInclusionManifest = zodIsFactory8(TransactionInclusionManifestZod);
+var asTransactionInclusionManifest = zodAsFactory9(
   TransactionInclusionManifestZod,
   "asTransactionInclusionManifest"
 );
-var toTransactionInclusionManifest = zodToFactory4(
+var toTransactionInclusionManifest = zodToFactory6(
   TransactionInclusionManifestZod,
   "toTransactionInclusionManifest"
 );
-var isTransactionInclusionHead = zodIsFactory5(TransactionInclusionHeadZod);
-var asTransactionInclusionHead = zodAsFactory6(
+var isTransactionInclusionHead = zodIsFactory8(TransactionInclusionHeadZod);
+var asTransactionInclusionHead = zodAsFactory9(
   TransactionInclusionHeadZod,
   "asTransactionInclusionHead"
 );
-var toTransactionInclusionHead = zodToFactory4(
+var toTransactionInclusionHead = zodToFactory6(
   TransactionInclusionHeadZod,
   "toTransactionInclusionHead"
 );
@@ -527,6 +774,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()}`;
@@ -561,6 +855,42 @@ function networkStakeRewardsIndexStepPath(policyId, step) {
   return `${root2(policyId)}/steps/${step.step}/${step.block}.json`;
 }
 
+// src/modules/network-model/staticRest/paths/slashIndex.ts
+var ROOT = "slash/v1";
+function slashIndexHeadPath() {
+  return `${ROOT}/head.json`;
+}
+function slashIndexManifestPath() {
+  return `${ROOT}/manifest.json`;
+}
+function slashIndexRequestPath(hash) {
+  return `${ROOT}/requests/by-hash/${hash}.json`;
+}
+function slashIndexCommitPath(hash) {
+  return `${ROOT}/commits/by-hash/${hash}.json`;
+}
+function slashIndexChallengePath(hash) {
+  return `${ROOT}/challenges/by-hash/${hash}.json`;
+}
+function slashIndexAdjudicationPath(hash) {
+  return `${ROOT}/adjudications/by-hash/${hash}.json`;
+}
+function slashIndexKeyPath(accused, offense, block) {
+  return `${ROOT}/keys/${accused.toLowerCase()}/${offense}/${block}.json`;
+}
+function slashIndexAccusedPath(address) {
+  return `${ROOT}/accused/${address.toLowerCase()}.json`;
+}
+function slashIndexClaimantPath(address) {
+  return `${ROOT}/claimants/${address.toLowerCase()}.json`;
+}
+function admissionShadowPath(height) {
+  return `admission/shadow/${height}.json`;
+}
+function admissionShadowHeadPath() {
+  return "admission/shadow/head.json";
+}
+
 // src/modules/network-model/utils/ExplorerLinks.ts
 var ExplorerLinks = class {
   /** Explorer origin with trailing slashes removed. */
@@ -621,13 +951,22 @@ var ExplorerLinks = class {
   }
 };
 export {
+  AdmissionShadowAssessmentZod,
+  AdmissionShadowReportSchema,
+  AdmissionShadowReportZod,
   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,13 +995,24 @@ export {
   NetworkStakeRewardsIndexSnapshotZod,
   NetworkStakeRewardsIndexStepZod,
   NetworkStakeRewardsPolicyIdZod,
+  RuleIdZod,
+  SLASH_INDEX_VERSION,
   SequenceNetwork,
   testnet_default as SequenceNetworkIconString,
+  SlashIndexHeadSchema,
+  SlashIndexHeadZod,
+  SlashIndexKeyRecordSchema,
+  SlashIndexKeyRecordZod,
   TRANSACTION_INCLUSION_INDEX_LAYOUT,
   TransactionInclusionHeadZod,
   TransactionInclusionManifestZod,
+  admissionShadowHeadPath,
+  admissionShadowPath,
+  asAdmissionShadowReport,
   asChainContractManifest,
   asChainManifest,
+  asChainParams,
+  asChainParamsHead,
   asEvmEventIndexFrame,
   asEvmEventIndexHead,
   asEvmEventIndexManifest,
@@ -673,6 +1023,8 @@ export {
   asNetworkStakeRewardsIndexSnapshot,
   asNetworkStakeRewardsIndexStep,
   asOptionalNetwork,
+  asSlashIndexHead,
+  asSlashIndexKeyRecord,
   asTransactionInclusionHead,
   asTransactionInclusionManifest,
   blockHashPath,
@@ -681,13 +1033,21 @@ export {
   blockNumberPathTemplate,
   chainContractByIdPath,
   chainManifestPathTemplates,
+  chainParamsHeadPath,
+  chainParamsSuccessionErrors,
+  chainParamsVersionPath,
+  createAdmissionShadowReport,
   createChainContractManifest,
   createChainManifest,
+  createChainParams,
+  createChainParamsHead,
   createIndexHead,
   createIndexManifest,
   createIndexManifestFamilies,
+  createSlashIndexHead,
   createTransactionInclusionHead,
   createTransactionInclusionManifest,
+  createTrustedPostureParams,
   evmEventIndexFramePath,
   evmEventIndexHeadPath,
   evmEventIndexManifestPath,
@@ -701,12 +1061,18 @@ export {
   indexSummaryPathTemplate,
   initNetworkNode,
   interpolatePathTemplate,
+  isAdmissionShadowReport,
   isChainContractManifest,
   isChainManifest,
+  isChainParams,
+  isChainParamsHead,
   isIndexHead,
   isIndexManifest,
   isNetworkBootstrap,
   isNetworkStakeRewardsIndexManifest,
+  isOffenseReportableAt,
+  isSlashIndexHead,
+  isSlashIndexKeyRecord,
   isTransactionInclusionHead,
   isTransactionInclusionManifest,
   manifestPath,
@@ -714,13 +1080,26 @@ export {
   networkStakeRewardsIndexManifestPath,
   networkStakeRewardsIndexSnapshotPath,
   networkStakeRewardsIndexStepPath,
+  offenseAdjudicationStateAt,
   payloadPath,
   payloadPathTemplate,
+  protocolMinAt,
+  slashIndexAccusedPath,
+  slashIndexAdjudicationPath,
+  slashIndexChallengePath,
+  slashIndexClaimantPath,
+  slashIndexCommitPath,
+  slashIndexHeadPath,
+  slashIndexKeyPath,
+  slashIndexManifestPath,
+  slashIndexRequestPath,
   toChainContractManifest,
   toChainManifest,
+  toChainParams,
   toIndexHead,
   toIndexManifest,
   toPathTemplate,
+  toSlashIndexHead,
   toTransactionInclusionHead,
   toTransactionInclusionManifest,
   transactionInclusionHeadPath,