@xyo-network/xl1-protocol 5.2.0 → 5.2.2

package/dist/neutral/network-model.mjs

@@ -106,34 +106,89 @@ 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({
+  /** Seasoned active stake measured at the evaluation point, hex atto, when it could be. */
+  activeStake: z.optional(z.string()),
+  /** 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()),
+  /** Whether the address held a current intent, when that could be established. */
+  intentValid: 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(),
+  /** The seasoned portion staked by the address on itself, hex atto, when it could be. */
+  selfBond: z.optional(z.string())
+});
+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(),
+  /** The admission posture that produced the round; reports keep flowing when gating starts. */
+  mode: z.optional(z.enum(["shadow", "enforce"])),
+  /** 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, mode) {
+  return AdmissionShadowReportZod.parse({
+    assessments,
+    divergent,
+    head,
+    mode,
+    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 +200,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";
@@ -234,23 +289,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({
@@ -264,98 +319,98 @@ function createChainManifest(encoding, earliestBlock = 0) {
 
 // src/modules/network-model/staticRest/layout/chainParams.ts
 import {
-  zodAsFactory as zodAsFactory3,
-  zodIsFactory as zodIsFactory3,
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
   zodToFactory as zodToFactory3
 } from "@ariestools/sdk";
-import { asSchema as asSchema2 } from "@xyo-network/sdk";
-import { z as z3 } from "zod";
+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 = asSchema2("network.xyo.s3.chain.params", true);
+var ChainParamsSchema = asSchema3("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({
+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: z3.partialRecord(RuleIdZod, HeightZod),
+  activations: z4.partialRecord(RuleIdZod, HeightZod),
   /** Address whose adjudication records are honored. */
-  arbiter: z3.string(),
+  arbiter: z4.string(),
   /** Share of a step's reward pool paid to attestors, in basis points. */
-  attestationRewardBps: z3.int().nonnegative(),
+  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: z3.int().nonnegative(),
+  bountyShareBps: z4.int().nonnegative(),
   /** Minimum share of every slash that must be burned, in basis points. */
-  burnFloorBps: z3.int().positive(),
+  burnFloorBps: z4.int().positive(),
   /** Version of the offense catalog these parameters describe. */
-  catalogVersion: z3.int().positive(),
+  catalogVersion: z4.int().positive(),
   /** Chain these parameters govern. */
   chainId: ChainIdZod2,
   /** Window during which counter-evidence may be filed, in EVM blocks. */
-  challengeWindowEvmBlocks: z3.int().positive(),
+  challengeWindowEvmBlocks: z4.int().positive(),
   /** Rule id to the height it stops taking effect; re-activation needs a later version. */
-  deactivations: z3.optional(z3.partialRecord(RuleIdZod, HeightZod)),
+  deactivations: z4.optional(z4.partialRecord(RuleIdZod, HeightZod)),
   /** Maximum age of an offense at report time, in EVM blocks. */
-  evidenceFreshnessEvmBlocks: z3.int().positive(),
+  evidenceFreshnessEvmBlocks: z4.int().positive(),
   /** Operational floor on how long evidence is kept, in XL1 blocks. */
-  evidenceRetentionXl1Blocks: z3.int().positive(),
+  evidenceRetentionXl1Blocks: z4.int().positive(),
   /** Delay between a certificate being queued and executable, in EVM blocks. */
-  executionDelayEvmBlocks: z3.int().positive(),
+  executionDelayEvmBlocks: z4.int().positive(),
   /** How far behind its own anchor a block's stake measurement may sit, in EVM blocks. */
-  freshnessBandEvmBlocks: z3.int().positive(),
+  freshnessBandEvmBlocks: z4.int().positive(),
   /** Blocks after an activation during which the rule is observed but not enforced. */
-  graceBandXl1Blocks: z3.int().nonnegative(),
+  graceBandXl1Blocks: z4.int().nonnegative(),
   /** Confirmation depth an anchor must sit behind the EVM head, in EVM blocks. */
-  maturityEvmBlocks: z3.int().positive(),
+  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: z3.int().nonnegative(),
+  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: z3.int().positive(),
+  opsAllowanceEvmBlocks: z4.int().positive(),
   /** Lowest protocol version a block may declare. */
-  protocolMin: z3.int().positive(),
+  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: z3.int().positive(),
+  revealDelayEvmBlocks: z4.int().positive(),
   /** Blocks a reveal must wait after its commitment, on the XL1 clock. */
-  revealDelayXl1Blocks: z3.int().positive(),
+  revealDelayXl1Blocks: z4.int().positive(),
   /** Blocks after which an unrevealed commitment expires. */
-  revealWindowEvmBlocks: z3.int().positive(),
+  revealWindowEvmBlocks: z4.int().positive(),
   /** Blocks after which an unrevealed commitment expires, on the XL1 clock. */
-  revealWindowXl1Blocks: z3.int().positive(),
+  revealWindowXl1Blocks: z4.int().positive(),
   /** Where the allowed block reward comes from. */
-  rewardSource: z3.enum(["schedule", "contract"]),
-  schema: z3.literal(ChainParamsSchema),
+  rewardSource: z4.enum(["schedule", "contract"]),
+  schema: z4.literal(ChainParamsSchema),
   /** Offense code to the share of at-risk stake it slashes, in basis points. */
-  slashFractionsBps: z3.partialRecord(offenseCodeZod, z3.int().nonnegative()),
+  slashFractionsBps: z4.partialRecord(offenseCodeZod, z4.int().nonnegative()),
   /** Distinct validator signatures a slash certificate needs. */
-  slashQuorumCount: z3.int().positive(),
+  slashQuorumCount: z4.int().positive(),
   /** Version of this register document. */
-  version: z3.int().positive()
+  version: z4.int().positive()
 });
-var isChainParams = zodIsFactory3(ChainParamsZod);
-var asChainParams = zodAsFactory3(ChainParamsZod, "asChainParams");
+var isChainParams = zodIsFactory4(ChainParamsZod);
+var asChainParams = zodAsFactory4(ChainParamsZod, "asChainParams");
 var toChainParams = zodToFactory3(ChainParamsZod, "toChainParams");
-var ChainParamsHeadSchema = asSchema2("network.xyo.s3.chain.params.head", true);
-var ChainParamsHeadZod = z3.object({
+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: z3.string(),
-  schema: z3.literal(ChainParamsHeadSchema),
+  hash: z4.string(),
+  schema: z4.literal(ChainParamsHeadSchema),
   /** Version number the pointer names. */
-  version: z3.int().positive()
+  version: z4.int().positive()
 });
-var isChainParamsHead = zodIsFactory3(ChainParamsHeadZod);
-var asChainParamsHead = zodAsFactory3(ChainParamsHeadZod, "asChainParamsHead");
+var isChainParamsHead = zodIsFactory4(ChainParamsHeadZod);
+var asChainParamsHead = zodAsFactory4(ChainParamsHeadZod, "asChainParamsHead");
 function createChainParams(config) {
   return ChainParamsZod.parse({ ...config, schema: ChainParamsSchema });
 }
@@ -392,111 +447,154 @@ function chainParamsSuccessionErrors(previous, next, finalizedHeight) {
   if (next.chainId !== previous.chainId) {
     errors.push(`chainId must not change: ${previous.chainId} -> ${next.chainId}`);
   }
+  if (next.protocolMin < previous.protocolMin) {
+    errors.push(`protocolMin must not lower: ${previous.protocolMin} -> ${next.protocolMin}`);
+  }
+  const previousDeactivations = previous.deactivations ?? {};
+  const nextDeactivations = next.deactivations ?? {};
+  const isReactivation = (ruleId) => {
+    const deactivation = previousDeactivations[ruleId];
+    const nextActivation = next.activations[ruleId];
+    return deactivation !== void 0 && deactivation <= finalizedHeight && nextActivation !== void 0 && nextActivation > finalizedHeight && nextDeactivations[ruleId] === void 0;
+  };
   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`);
-    }
+    if (next.activations[ruleId] === height) continue;
+    if (isReactivation(ruleId)) continue;
+    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) {
+  for (const [ruleId, height] of Object.entries(previousDeactivations)) {
+    if (height > finalizedHeight) continue;
+    if (nextDeactivations[ruleId] === height) continue;
+    if (isReactivation(ruleId)) continue;
+    errors.push(`deactivation for '${ruleId}' is already in force at ${height} and must not move`);
+  }
+  for (const [ruleId, height] of Object.entries(nextDeactivations)) {
+    if (height < finalizedHeight && previousDeactivations[ruleId] !== height) {
       errors.push(`deactivation for '${ruleId}' at ${height} is in the past`);
     }
   }
   return errors;
 }
+function chainParamsInvariantErrors(params) {
+  const errors = [];
+  if (params.burnFloorBps + params.bountyShareBps > 1e4) {
+    errors.push(`burnFloorBps + bountyShareBps must not exceed 10000: ${params.burnFloorBps} + ${params.bountyShareBps}`);
+  }
+  const minValidatorStake = tryBigInt(params.minValidatorStakeAtto);
+  const bountyCap = tryBigInt(params.bountyCapAtto);
+  if (minValidatorStake === void 0 || bountyCap === void 0) {
+    errors.push("minValidatorStakeAtto and bountyCapAtto must be parseable amounts");
+    return errors;
+  }
+  const counterSlashBps = BigInt(params.slashFractionsBps["invalid-slash-request"] ?? 0);
+  const counterSlashMin = minValidatorStake * counterSlashBps / 10000n;
+  if (counterSlashMin < bountyCap * 2n) {
+    errors.push(
+      `the counter-slash at minimum validator stake (${counterSlashMin}) must be at least twice bountyCapAtto (${bountyCap})`
+    );
+  }
+  return errors;
+}
+function tryBigInt(value) {
+  try {
+    return BigInt(value.startsWith("0x") ? value : `0x${value}`);
+  } catch {
+    return void 0;
+  }
+}
 
 // src/modules/network-model/staticRest/layout/evmEventIndex.ts
 import {
   EthAddressZod,
   HexRegExMinMaxMixedCaseWithPrefix,
-  zodAsFactory as zodAsFactory4
+  zodAsFactory as zodAsFactory5
 } from "@ariestools/sdk";
-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({
+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: z4.number(),
+  blockNumber: z5.number(),
   data: EvmDataZod,
-  index: z4.number(),
-  topics: z4.array(EvmHashZod),
+  index: z5.number(),
+  topics: z5.array(EvmHashZod),
   transactionHash: EvmHashZod,
-  transactionIndex: z4.number()
+  transactionIndex: z5.number()
 });
-var EvmEventIndexFrameZod = z4.object({
-  fromBlock: z4.number(),
-  logs: z4.array(EvmEventIndexLogZod),
-  toBlock: z4.number()
+var EvmEventIndexFrameZod = z5.object({
+  fromBlock: z5.number(),
+  logs: z5.array(EvmEventIndexLogZod),
+  toBlock: z5.number()
 });
-var EvmEventIndexManifestZod = z4.object({
+var EvmEventIndexManifestZod = z5.object({
   address: EthAddressZod,
-  chainId: z4.string(),
-  deploymentBlock: z4.number(),
-  frameSize: z4.number(),
-  layout: z4.literal("evm-contract-events-v1")
+  chainId: z5.string(),
+  deploymentBlock: z5.number(),
+  frameSize: z5.number(),
+  layout: z5.literal("evm-contract-events-v1")
 });
-var EvmEventIndexHeadZod = z4.object({
+var EvmEventIndexHeadZod = z5.object({
   address: EthAddressZod,
-  block: z4.number(),
-  chainId: z4.string(),
+  block: z5.number(),
+  chainId: z5.string(),
   hash: EvmHashZod
 });
-var asEvmEventIndexFrame = zodAsFactory4(EvmEventIndexFrameZod, "asEvmEventIndexFrame");
-var asEvmEventIndexHead = zodAsFactory4(EvmEventIndexHeadZod, "asEvmEventIndexHead");
-var asEvmEventIndexManifest = zodAsFactory4(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 zodAsFactory5,
-  zodIsFactory as zodIsFactory4,
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory5,
   zodToFactory as zodToFactory4
 } from "@ariestools/sdk";
-import { z as z5 } 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 = z5.object({
+var IndexManifestFamilyZod = z6.object({
   /** Highest step level published for this family. */
-  maxStep: z5.int().nonnegative(),
+  maxStep: z6.int().nonnegative(),
   /** Path template for the family's frames, e.g. `blocks/{level}/{index}.json`. */
-  path: z5.string()
+  path: z6.string()
 });
-var indexFamiliesZod = z5.object({
+var indexFamiliesZod = z6.object({
   balances: IndexManifestFamilyZod,
   blocks: IndexManifestFamilyZod,
   schemas: IndexManifestFamilyZod,
   transfers: IndexManifestFamilyZod
 });
-var IndexManifestZod = z5.object({
+var IndexManifestZod = z6.object({
   families: indexFamiliesZod,
-  schema: z5.literal(IndexManifestSchema),
-  version: z5.int().positive()
+  schema: z6.literal(IndexManifestSchema),
+  version: z6.int().positive()
 });
-var isIndexManifest = zodIsFactory4(IndexManifestZod);
-var asIndexManifest = zodAsFactory5(IndexManifestZod, "asIndexManifest");
+var isIndexManifest = zodIsFactory5(IndexManifestZod);
+var asIndexManifest = zodAsFactory6(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 IndexHeadFamiliesZod = z6.object({
+  balances: z6.int().nonnegative(),
+  blocks: z6.int().nonnegative(),
+  schemas: z6.int().nonnegative(),
+  transfers: z6.int().nonnegative()
 });
-var IndexHeadZod = z5.object({
+var IndexHeadZod = z6.object({
   /** Highest block the index is complete through. */
-  block: z5.int().nonnegative(),
+  block: z6.int().nonnegative(),
   /** Completed frame counts per family. */
   families: IndexHeadFamiliesZod,
   /** Hash of that block. */
-  hash: z5.string(),
-  schema: z5.literal(IndexHeadSchema),
+  hash: z6.string(),
+  schema: z6.literal(IndexHeadSchema),
   /** ISO-8601 timestamp of the last update. */
-  updatedAt: z5.string(),
-  version: z5.int().positive()
+  updatedAt: z6.string(),
+  version: z6.int().positive()
 });
-var isIndexHead = zodIsFactory4(IndexHeadZod);
-var asIndexHead = zodAsFactory5(IndexHeadZod, "asIndexHead");
+var isIndexHead = zodIsFactory5(IndexHeadZod);
+var asIndexHead = zodAsFactory6(IndexHeadZod, "asIndexHead");
 var toIndexHead = zodToFactory4(IndexHeadZod, "toIndexHead");
 function createIndexManifestFamilies(maxSteps) {
   return {
@@ -529,107 +627,162 @@ function createIndexHead(watermark, updatedAt) {
 // src/modules/network-model/staticRest/layout/networkStakeRewardsIndex.ts
 import {
   HashZod,
-  zodAsFactory as zodAsFactory6,
-  zodIsFactory as zodIsFactory5
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory6
 } from "@ariestools/sdk";
-import { asSchema as asSchema3 } from "@xyo-network/sdk";
-import { z as z6 } 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 = 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 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 = z6.object({
-  evmAddress: z6.string(),
-  evmChainId: z6.string(),
-  layout: z6.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: z6.array(z6.number().int().nonnegative()),
-  timeAnchor: z6.object({
-    externalGenesisTime: z6.number().optional(),
-    maxScanBlocks: z6.number().optional()
+  stepLevels: z7.array(z7.number().int().nonnegative()),
+  timeAnchor: z7.object({
+    externalGenesisTime: z7.number().optional(),
+    maxScanBlocks: z7.number().optional()
   }).optional()
 });
-var NetworkStakeRewardsIndexStepZod = z6.object({
+var NetworkStakeRewardsIndexStepZod = z7.object({
   denominator: DecimalBigIntZod,
   externalRange: BlockRangeZod,
-  layout: z6.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 = z6.object({
-  layout: z6.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+var NetworkStakeRewardsIndexSnapshotZod = z7.object({
+  layout: z7.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
   policyId: NetworkStakeRewardsPolicyIdZod,
   positionRewards: PositionRewardsZod,
-  schema: z6.literal(NetworkStakeRewardsIndexSnapshotSchema),
-  stepCount: z6.number().int().nonnegative(),
+  schema: z7.literal(NetworkStakeRewardsIndexSnapshotSchema),
+  stepCount: z7.number().int().nonnegative(),
   totalReward: DecimalBigIntZod
 });
-var NetworkStakeRewardsIndexHeadZod = z6.object({
-  layout: z6.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+var NetworkStakeRewardsIndexHeadZod = z7.object({
+  layout: z7.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
   policyId: NetworkStakeRewardsPolicyIdZod,
-  positionCount: z6.number().int().nonnegative(),
-  processedThroughBlock: z6.number().int().nonnegative(),
+  positionCount: z7.number().int().nonnegative(),
+  processedThroughBlock: z7.number().int().nonnegative(),
   snapshotHash: HashZod,
-  source: z6.object({
-    evm: z6.object({
-      block: z6.number().int().nonnegative(),
-      hash: z6.string()
+  source: z7.object({
+    evm: z7.object({
+      block: z7.number().int().nonnegative(),
+      hash: z7.string()
     }),
-    xl1: z6.object({
-      block: z6.number().int().nonnegative(),
-      hash: z6.string()
+    xl1: z7.object({
+      block: z7.number().int().nonnegative(),
+      hash: z7.string()
     })
   }),
-  stepCount: z6.number().int().nonnegative()
+  stepCount: z7.number().int().nonnegative()
 });
-var isNetworkStakeRewardsIndexManifest = zodIsFactory5(NetworkStakeRewardsIndexManifestZod);
-var asNetworkStakeRewardsIndexManifest = zodAsFactory6(
+var isNetworkStakeRewardsIndexManifest = zodIsFactory6(NetworkStakeRewardsIndexManifestZod);
+var asNetworkStakeRewardsIndexManifest = zodAsFactory7(
   NetworkStakeRewardsIndexManifestZod,
   "asNetworkStakeRewardsIndexManifest"
 );
-var asNetworkStakeRewardsIndexStep = zodAsFactory6(
+var asNetworkStakeRewardsIndexStep = zodAsFactory7(
   NetworkStakeRewardsIndexStepZod,
   "asNetworkStakeRewardsIndexStep"
 );
-var asNetworkStakeRewardsIndexSnapshot = zodAsFactory6(
+var asNetworkStakeRewardsIndexSnapshot = zodAsFactory7(
   NetworkStakeRewardsIndexSnapshotZod,
   "asNetworkStakeRewardsIndexSnapshot"
 );
-var asNetworkStakeRewardsIndexHead = zodAsFactory6(
+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 zodAsFactory7,
-  zodIsFactory as zodIsFactory6,
-  zodToFactory as zodToFactory5
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory8,
+  zodToFactory as zodToFactory6
 } from "@ariestools/sdk";
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 import { ChainIdZod as ChainIdZod3, XL1BlockNumberZod } from "#protocol-model";
 var TRANSACTION_INCLUSION_INDEX_LAYOUT = "transaction-inclusions-v1";
-var TransactionInclusionManifestZod = z7.object({
+var TransactionInclusionManifestZod = z9.object({
   /** XL1 chain whose finalized transactions are indexed. */
   chain: ChainIdZod3,
   /** Versioned layout identifier. */
-  layout: z7.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT),
+  layout: z9.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT),
   /** Hash-addressed path template, for example `transactions/by-hash/{hash}.json`. */
-  path: z7.string()
+  path: z9.string()
 });
-var TransactionInclusionHeadZod = z7.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. */
@@ -637,25 +790,25 @@ var TransactionInclusionHeadZod = z7.object({
   /** XL1 chain whose finalized transactions are indexed. */
   chain: ChainIdZod3,
   /** Number of transaction-inclusion records represented through `block`. */
-  entries: z7.int().nonnegative(),
+  entries: z9.int().nonnegative(),
   /** Versioned layout identifier. */
-  layout: z7.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT)
+  layout: z9.literal(TRANSACTION_INCLUSION_INDEX_LAYOUT)
 });
-var isTransactionInclusionManifest = zodIsFactory6(TransactionInclusionManifestZod);
-var asTransactionInclusionManifest = zodAsFactory7(
+var isTransactionInclusionManifest = zodIsFactory8(TransactionInclusionManifestZod);
+var asTransactionInclusionManifest = zodAsFactory9(
   TransactionInclusionManifestZod,
   "asTransactionInclusionManifest"
 );
-var toTransactionInclusionManifest = zodToFactory5(
+var toTransactionInclusionManifest = zodToFactory6(
   TransactionInclusionManifestZod,
   "toTransactionInclusionManifest"
 );
-var isTransactionInclusionHead = zodIsFactory6(TransactionInclusionHeadZod);
-var asTransactionInclusionHead = zodAsFactory7(
+var isTransactionInclusionHead = zodIsFactory8(TransactionInclusionHeadZod);
+var asTransactionInclusionHead = zodAsFactory9(
   TransactionInclusionHeadZod,
   "asTransactionInclusionHead"
 );
-var toTransactionInclusionHead = zodToFactory5(
+var toTransactionInclusionHead = zodToFactory6(
   TransactionInclusionHeadZod,
   "toTransactionInclusionHead"
 );
@@ -754,6 +907,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. */
@@ -814,6 +1003,9 @@ var ExplorerLinks = class {
   }
 };
 export {
+  AdmissionShadowAssessmentZod,
+  AdmissionShadowReportSchema,
+  AdmissionShadowReportZod,
   CHAIN_CONTRACT_MANIFEST_VERSION,
   CHAIN_LAYOUT_VERSION,
   CHAIN_PARAMS_VERSION,
@@ -856,11 +1048,19 @@ export {
   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,
@@ -875,6 +1075,8 @@ export {
   asNetworkStakeRewardsIndexSnapshot,
   asNetworkStakeRewardsIndexStep,
   asOptionalNetwork,
+  asSlashIndexHead,
+  asSlashIndexKeyRecord,
   asTransactionInclusionHead,
   asTransactionInclusionManifest,
   blockHashPath,
@@ -884,8 +1086,10 @@ export {
   chainContractByIdPath,
   chainManifestPathTemplates,
   chainParamsHeadPath,
+  chainParamsInvariantErrors,
   chainParamsSuccessionErrors,
   chainParamsVersionPath,
+  createAdmissionShadowReport,
   createChainContractManifest,
   createChainManifest,
   createChainParams,
@@ -893,6 +1097,7 @@ export {
   createIndexHead,
   createIndexManifest,
   createIndexManifestFamilies,
+  createSlashIndexHead,
   createTransactionInclusionHead,
   createTransactionInclusionManifest,
   createTrustedPostureParams,
@@ -909,6 +1114,7 @@ export {
   indexSummaryPathTemplate,
   initNetworkNode,
   interpolatePathTemplate,
+  isAdmissionShadowReport,
   isChainContractManifest,
   isChainManifest,
   isChainParams,
@@ -918,6 +1124,8 @@ export {
   isNetworkBootstrap,
   isNetworkStakeRewardsIndexManifest,
   isOffenseReportableAt,
+  isSlashIndexHead,
+  isSlashIndexKeyRecord,
   isTransactionInclusionHead,
   isTransactionInclusionManifest,
   manifestPath,
@@ -929,12 +1137,22 @@ export {
   payloadPath,
   payloadPathTemplate,
   protocolMinAt,
+  slashIndexAccusedPath,
+  slashIndexAdjudicationPath,
+  slashIndexChallengePath,
+  slashIndexClaimantPath,
+  slashIndexCommitPath,
+  slashIndexHeadPath,
+  slashIndexKeyPath,
+  slashIndexManifestPath,
+  slashIndexRequestPath,
   toChainContractManifest,
   toChainManifest,
   toChainParams,
   toIndexHead,
   toIndexManifest,
   toPathTemplate,
+  toSlashIndexHead,
   toTransactionInclusionHead,
   toTransactionInclusionManifest,
   transactionInclusionHeadPath,