@xyo-network/chain-sdk 5.0.4 → 5.1.0

package/dist/neutral/slashing.mjs

@@ -0,0 +1,824 @@
+// src/modules/slashing/detect/candidatePairs.ts
+function competes(first, second) {
+  if (first.dataHash === second.dataHash) return false;
+  return first.block === second.block || first.previous === second.previous;
+}
+function linked(first, second) {
+  return first.supersedes === second.dataHash || second.supersedes === first.dataHash;
+}
+function findCandidatePairs(sightings) {
+  const byProducer = /* @__PURE__ */ new Map();
+  for (const sighting of sightings) {
+    const seen = byProducer.get(sighting.producer) ?? [];
+    if (!seen.some((candidate) => candidate.dataHash === sighting.dataHash)) seen.push(sighting);
+    byProducer.set(sighting.producer, seen);
+  }
+  const pairs = [];
+  for (const [producer, candidates] of byProducer) {
+    for (const [index, first] of candidates.entries()) {
+      for (const second of candidates.slice(index + 1)) {
+        if (!competes(first, second) || linked(first, second)) continue;
+        pairs.push({
+          block: Math.max(first.block, second.block),
+          first,
+          producer,
+          second
+        });
+      }
+    }
+  }
+  return pairs;
+}
+
+// src/modules/slashing/detect/offenseGate.ts
+import { isOffenseReportableAt, isRuleObservedAt } from "@xyo-network/xl1-sdk";
+function isOffenseWatchable(params, offense, height) {
+  if (!isOffenseReportableAt(params, offense, height)) return false;
+  return offense === "equivocation" ? isRuleObservedAt(params, "supersedes-field", height) : true;
+}
+
+// src/modules/slashing/detect/suppression.ts
+async function suppressionFor(history, key) {
+  if (await history.adjudicationByKey(key) !== void 0) return "adjudicated";
+  return (await history.requestsByKey(key)).length > 0 ? "already-reported" : void 0;
+}
+
+// src/modules/slashing/eligibility/evaluateProducerEligibility.ts
+import { evaluationPoint, producerIneligibility } from "@xyo-network/xl1-sdk";
+async function evaluateProducerEligibility(input) {
+  const {
+    accused,
+    blockAnchor,
+    height,
+    intent,
+    params,
+    parentAnchor,
+    snapshot
+  } = input;
+  if (blockAnchor === void 0 || parentAnchor === void 0) {
+    return { resolvable: false };
+  }
+  if (snapshot === void 0) {
+    return { eStar: evaluationPoint(parentAnchor, blockAnchor, params.freshnessBandEvmBlocks), resolvable: false };
+  }
+  const eStar = evaluationPoint(parentAnchor, blockAnchor, params.freshnessBandEvmBlocks);
+  const minAge = params.minStakeAgeEvmBlocks;
+  const [seasonedActive, seasonedSelfBond, active, intentValid] = await Promise.all([
+    snapshot.seasonedActiveByStakedAt(accused, eStar, minAge),
+    snapshot.seasonedSelfBondAt(accused, eStar, minAge),
+    snapshot.activeByStakedAt(accused, eStar),
+    intent(accused, height)
+  ]);
+  if (intentValid === void 0) {
+    return {
+      activeStake: seasonedActive,
+      eStar,
+      resolvable: false,
+      selfBond: seasonedSelfBond
+    };
+  }
+  const standing = {
+    active,
+    seasonedActive,
+    seasonedSelfBond
+  };
+  const reason = producerIneligibility(
+    standing,
+    {
+      minSelfBond: hexAtto(params.minProducerSelfBondAtto),
+      minStake: hexAtto(params.minProducerStakeAtto)
+    },
+    intentValid
+  );
+  return {
+    activeStake: seasonedActive,
+    eStar,
+    eligible: reason === null,
+    intentValid,
+    reason: reason ?? void 0,
+    resolvable: true,
+    selfBond: seasonedSelfBond
+  };
+}
+function hexAtto(value) {
+  if (value === "") return 0n;
+  return BigInt(value.startsWith("0x") ? value : `0x${value}`);
+}
+
+// src/modules/slashing/index/foldSlashIndex.ts
+import {
+  isSlashAdjudication,
+  isSlashChallenge,
+  isSlashCommit,
+  isSlashRequest,
+  slashIndexAccusedPath,
+  slashIndexAdjudicationPath,
+  slashIndexChallengePath,
+  slashIndexCommitPath,
+  slashIndexKeyPath,
+  SlashIndexKeyRecordSchema,
+  slashIndexRequestPath
+} from "@xyo-network/xl1-sdk";
+
+// src/modules/slashing/model/offenseKey.ts
+function offenseKeyOf(request) {
+  return {
+    accused: request.accused,
+    block: request.block,
+    chain: request.chain,
+    offense: request.offense
+  };
+}
+function offenseKeyString(key) {
+  return `${key.chain}|${key.accused}|${key.offense}|${key.block}`;
+}
+function canonicalOffenseHeight(request) {
+  return request.block;
+}
+
+// src/modules/slashing/index/foldSlashIndex.ts
+var emptyDelta = () => ({
+  accused: /* @__PURE__ */ new Map(),
+  keys: /* @__PURE__ */ new Map(),
+  pending: [],
+  records: []
+});
+var recordAt = (path, payload) => ({
+  immutable: true,
+  path,
+  value: payload
+});
+function foldSlashIndex(blocks) {
+  const delta = emptyDelta();
+  const keyPathByRequest = /* @__PURE__ */ new Map();
+  for (const [, payloads] of blocks) {
+    for (const payload of payloads) foldPayload(delta, keyPathByRequest, payload);
+  }
+  return delta;
+}
+function keyPathFor(delta, request) {
+  const key = offenseKeyOf(request);
+  const path = slashIndexKeyPath(key.accused, key.offense, key.block);
+  if (!delta.keys.has(path)) {
+    delta.keys.set(path, {
+      accused: key.accused,
+      block: key.block,
+      challenges: [],
+      chain: key.chain,
+      offense: key.offense,
+      requests: [],
+      schema: SlashIndexKeyRecordSchema
+    });
+    const accusedPath = slashIndexAccusedPath(key.accused);
+    delta.accused.set(accusedPath, [...delta.accused.get(accusedPath) ?? [], offenseKeyString(key)]);
+  }
+  return path;
+}
+function foldPayload(delta, keyPathByRequest, payload) {
+  if (isSlashRequest(payload)) {
+    delta.records.push(recordAt(slashIndexRequestPath(payload._dataHash), payload));
+    const path = keyPathFor(delta, payload);
+    keyPathByRequest.set(payload._dataHash, path);
+    const record = delta.keys.get(path);
+    if (record !== void 0 && !record.requests.includes(payload._dataHash)) {
+      record.requests.push(payload._dataHash);
+    }
+    return;
+  }
+  if (isSlashCommit(payload)) {
+    delta.records.push(recordAt(slashIndexCommitPath(payload._dataHash), payload));
+    return;
+  }
+  if (isSlashChallenge(payload)) {
+    delta.records.push(recordAt(slashIndexChallengePath(payload._dataHash), payload));
+    linkToRequest(delta, keyPathByRequest, payload._dataHash, payload.request, "challenge");
+    return;
+  }
+  if (isSlashAdjudication(payload)) {
+    delta.records.push(recordAt(slashIndexAdjudicationPath(payload._dataHash), payload));
+    const path = linkToRequest(delta, keyPathByRequest, payload._dataHash, payload.request, "adjudication");
+    const record = path === void 0 ? void 0 : delta.keys.get(path);
+    if (record !== void 0) {
+      record.adjudication = payload._dataHash;
+      record.outcome = payload.outcome;
+    }
+  }
+}
+function linkToRequest(delta, keyPathByRequest, hash, request, kind) {
+  const path = keyPathByRequest.get(request);
+  if (path === void 0) {
+    delta.pending.push({
+      hash,
+      kind,
+      request
+    });
+    return void 0;
+  }
+  if (kind === "challenge") {
+    const record = delta.keys.get(path);
+    if (record !== void 0 && !record.challenges.includes(hash)) record.challenges.push(hash);
+  }
+  return path;
+}
+function mergeKeyRecord(existing, next) {
+  if (existing === void 0) return next;
+  const union = (left, right) => [.../* @__PURE__ */ new Set([...left, ...right])];
+  return {
+    ...existing,
+    ...next,
+    // set-once: a verdict already recorded is never replaced by a later pass
+    adjudication: existing.adjudication ?? next.adjudication,
+    challenges: union(existing.challenges, next.challenges),
+    outcome: existing.outcome ?? next.outcome,
+    requests: union(existing.requests, next.requests)
+  };
+}
+
+// src/modules/slashing/index/SlashIndexStore.ts
+var SlashIndexStoreMoniker = "SlashIndexStore";
+function isSlashIndexStore(value) {
+  const candidate = value;
+  return typeof candidate?.readObject === "function" && typeof candidate.hasObject === "function" && typeof candidate.writeObject === "function";
+}
+
+// src/modules/slashing/model/VerificationOutcome.ts
+var VerificationOutcomes = ["verified", "indeterminate", "provably-invalid"];
+function verdict(outcome, reason, transcript = {}, provisional) {
+  return provisional === void 0 ? {
+    outcome,
+    reason,
+    transcript
+  } : {
+    outcome,
+    provisional,
+    reason,
+    transcript
+  };
+}
+
+// src/modules/slashing/verify/preamble.ts
+import { isBoundWitness, PayloadBuilder } from "@xyo-network/sdk";
+import { BoundWitnessSignaturesValidator } from "@xyo-network/xl1-sdk";
+async function verifyArtifacts(artifacts, referenced) {
+  const byHash = /* @__PURE__ */ new Map();
+  for (const claimed of referenced) {
+    const candidate = artifacts.get(claimed);
+    if (candidate === void 0) {
+      return {
+        missing: true,
+        ok: false,
+        reason: `cited artifact ${claimed} is not available to this verifier`
+      };
+    }
+    const payload = candidate;
+    const dataHash = await PayloadBuilder.dataHash(payload);
+    if (dataHash !== claimed) {
+      return { ok: false, reason: `artifact cited as ${claimed} hashes to ${dataHash}` };
+    }
+    if (isBoundWitness(payload)) {
+      const signatureErrors = await BoundWitnessSignaturesValidator(payload);
+      if (signatureErrors.length > 0) {
+        return { ok: false, reason: `artifact ${dataHash} carries an invalid signature` };
+      }
+    }
+    byHash.set(dataHash, {
+      dataHash,
+      payload,
+      storageHash: await PayloadBuilder.hash(payload)
+    });
+  }
+  return { byHash, ok: true };
+}
+async function referencesArtifact(reference, artifact) {
+  if (reference === null || reference === void 0) return false;
+  if (reference === artifact.dataHash) return true;
+  const storageHash = artifact.storageHash ?? await PayloadBuilder.hash(artifact.payload);
+  return reference === storageHash;
+}
+async function freshnessGate(ctx, request) {
+  const eOff = await ctx.chain.validatedAnchorAt(request.block);
+  if (eOff === void 0) {
+    return {
+      reason: "no anchor resolvable at the offense height",
+      verdict: verdict("indeterminate", "no anchor resolvable at the offense height")
+    };
+  }
+  const submissionHeight = ctx.submission.commitCarryingHeight ?? ctx.submission.requestCarryingHeight;
+  const eSub = await ctx.chain.validatedAnchorAt(submissionHeight);
+  if (eSub === void 0) {
+    return {
+      eOff,
+      reason: "no anchor resolvable at the submission height",
+      verdict: verdict("indeterminate", "no anchor resolvable at the submission height")
+    };
+  }
+  const age = eSub - eOff;
+  if (age > ctx.params.evidenceFreshnessEvmBlocks) {
+    const reason = `offense is ${age} EVM blocks old, past the ${ctx.params.evidenceFreshnessEvmBlocks} limit`;
+    return {
+      eOff,
+      eSub,
+      reason,
+      verdict: verdict("provably-invalid", reason, {
+        age,
+        eOff,
+        eSub
+      })
+    };
+  }
+  return {
+    eOff,
+    eSub,
+    reason: `offense is ${age} EVM blocks old`
+  };
+}
+
+// src/modules/slashing/verify/verifyEquivocation.ts
+import { asBlockBoundWitness } from "@xyo-network/xl1-sdk";
+var asCitedBlock = (artifact) => {
+  const block = asBlockBoundWitness(artifact.payload);
+  return block === void 0 ? void 0 : { block, dataHash: artifact.dataHash };
+};
+var verifyEquivocation = async (_ctx, request, artifacts) => {
+  const cited = [...artifacts.values()];
+  if (cited.length !== 2) {
+    return verdict("provably-invalid", `equivocation needs two distinct blocks, got ${cited.length}`);
+  }
+  const blocks = cited.map((artifact) => asCitedBlock(artifact));
+  const [first, second] = blocks;
+  if (first === void 0 || second === void 0) {
+    return verdict("provably-invalid", "cited artifacts are not both blocks");
+  }
+  const transcript = {
+    accused: request.accused,
+    first: {
+      block: first.block.block,
+      dataHash: first.dataHash,
+      previous: first.block.previous,
+      supersedes: first.block.supersedes ?? null
+    },
+    second: {
+      block: second.block.block,
+      dataHash: second.dataHash,
+      previous: second.block.previous,
+      supersedes: second.block.supersedes ?? null
+    }
+  };
+  if (!blocks.every((cite) => cite?.block.addresses.includes(request.accused))) {
+    return verdict("provably-invalid", "the accused did not sign both blocks", transcript);
+  }
+  if (first.block.chain !== second.block.chain) {
+    return verdict("provably-invalid", "the blocks are on different chains", transcript);
+  }
+  if (first.block.chain !== request.chain) {
+    return verdict("provably-invalid", "the blocks are not on the chain the report names", transcript);
+  }
+  if (first.block.block !== request.block && second.block.block !== request.block) {
+    return verdict("provably-invalid", "the report does not locate the offense at either cited block", transcript);
+  }
+  if (first.block.block !== second.block.block && first.block.previous !== second.block.previous) {
+    return verdict("provably-invalid", "the blocks neither share a height nor a parent", transcript);
+  }
+  const superseded = /* @__PURE__ */ new Set([first.block.supersedes, second.block.supersedes]);
+  if (superseded.has(first.dataHash) || superseded.has(second.dataHash)) {
+    return verdict("provably-invalid", "one block supersedes the other, so this is a re-proposal", transcript);
+  }
+  return verdict("verified", "two competing candidates with no supersedes link between them", transcript);
+};
+
+// src/modules/slashing/verify/verifyFalseAnchor.ts
+import { isDefined } from "@ariestools/sdk";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
+import { asBlockBoundWitness as asBlockBoundWitness2, isTimePayload } from "@xyo-network/xl1-sdk";
+async function anchoredBlocks(artifacts) {
+  const cited = [...artifacts.values()];
+  const times = await Promise.all(cited.filter((artifact) => isTimePayload(artifact.payload)).map(async (artifact) => ({
+    hashes: [artifact.dataHash, artifact.storageHash ?? await PayloadBuilder2.hash(artifact.payload)].filter((hash) => isDefined(hash)),
+    time: artifact.payload
+  })));
+  return cited.flatMap((artifact) => {
+    const block = asBlockBoundWitness2(artifact.payload);
+    return block === void 0 ? [] : [{ artifact, block }];
+  }).map(({ artifact, block }) => {
+    const carried = new Set(block.payload_hashes);
+    const time = times.find((candidate) => candidate.hashes.some((hash) => carried.has(hash)));
+    return {
+      artifact,
+      block,
+      evm: time?.time?.ethereum,
+      evmHash: time?.time?.ethereumHash
+    };
+  });
+}
+async function parentOf(accused, blocks) {
+  for (const candidate of blocks) {
+    if (candidate === accused) continue;
+    if (await referencesArtifact(accused.block.previous, candidate.artifact)) return candidate;
+  }
+  return void 0;
+}
+var verifyFalseAnchor = async (ctx, request, artifacts) => {
+  const blocks = await anchoredBlocks(artifacts);
+  const accused = blocks.find((candidate) => candidate.block.block === request.block);
+  if (accused === void 0) return verdict("provably-invalid", "the accused block was not among the cited artifacts");
+  const parent = await parentOf(accused, blocks);
+  if (accused.evm === void 0 || accused.evmHash === void 0) {
+    return verdict("provably-invalid", "the accused block carries no EVM anchor to be false about");
+  }
+  if (!accused.block.addresses.includes(request.accused)) {
+    return verdict("provably-invalid", "the accused did not sign the cited block");
+  }
+  const transcript = {
+    accused: request.accused,
+    block: accused.block.block,
+    claimedEvm: accused.evm,
+    claimedEvmHash: accused.evmHash,
+    parentEvm: parent?.evm ?? null
+  };
+  if (parent?.evm !== void 0 && accused.evm < parent.evm) {
+    return verdict("verified", `the anchor went backwards, from ${parent.evm} to ${accused.evm}`, transcript);
+  }
+  if (request.evm !== accused.evm) {
+    return verdict("provably-invalid", "the report does not name the anchor the block claims", transcript);
+  }
+  if (ctx.evm === void 0) {
+    return verdict("indeterminate", "no EVM view, so the claimed anchor cannot be checked", transcript);
+  }
+  const head = await ctx.evm.head();
+  if (head === void 0) {
+    return verdict("indeterminate", "the EVM head is not resolvable", transcript);
+  }
+  if (head - accused.evm < ctx.params.maturityEvmBlocks) {
+    return verdict("indeterminate", `the anchor is only ${head - accused.evm} EVM blocks deep and has not matured`, { ...transcript, head });
+  }
+  const canonical = await ctx.evm.canonicalHashAt(accused.evm);
+  if (canonical === void 0) {
+    return verdict("indeterminate", "the canonical hash at that EVM height is not resolvable", transcript);
+  }
+  return canonical === accused.evmHash ? verdict("provably-invalid", "the block anchored to the canonical hash at that height", { ...transcript, canonical }) : verdict("verified", "the block anchored to a hash the EVM never had at that height", { ...transcript, canonical });
+};
+
+// src/modules/slashing/verify/verifyFalseAttestation.ts
+import { isBoundWitness as isBoundWitness2 } from "@xyo-network/sdk";
+import {
+  asBlockBoundWitness as asBlockBoundWitness3,
+  isStepWitness,
+  StepSizes
+} from "@xyo-network/xl1-sdk";
+var citedAttestation = (cited) => {
+  const entry = cited.find((artifact) => isStepWitness(artifact.payload));
+  return entry === void 0 ? void 0 : { artifact: entry, attestation: entry.payload };
+};
+async function boundToAccused(cited, attestation, accused) {
+  for (const artifact of cited) {
+    const payload = artifact.payload;
+    if (!isBoundWitness2(artifact.payload)) continue;
+    if (!(payload.addresses?.includes(accused) ?? false)) continue;
+    for (const carried of payload.payload_hashes ?? []) {
+      if (await referencesArtifact(carried, attestation.artifact)) return true;
+    }
+  }
+  return false;
+}
+var verifyFalseAttestation = async (ctx, request, artifacts) => {
+  const cited = [...artifacts.values()];
+  const found = citedAttestation(cited);
+  if (found === void 0) {
+    return verdict("provably-invalid", "no attestation among the cited artifacts");
+  }
+  const { attestation } = found;
+  const transcript = {
+    accused: request.accused,
+    attestedBlock: attestation.blockNumber,
+    attestedBlockHash: attestation.blockHash,
+    attestedStepHash: attestation.stepHash,
+    stepSize: attestation.stepSize
+  };
+  if (attestation.witness !== request.accused || !await boundToAccused(cited, found, request.accused)) {
+    return verdict("provably-invalid", "the attestation is not bound to the accused by any cited signed carrier", transcript);
+  }
+  const level = StepSizes.indexOf(attestation.stepSize);
+  if (level === -1) {
+    return verdict("provably-invalid", `the attestation names an unknown step size ${attestation.stepSize}`, transcript);
+  }
+  const attested = cited.map((artifact) => ({ block: asBlockBoundWitness3(artifact.payload), dataHash: artifact.dataHash })).find((candidate) => candidate.block !== void 0 && candidate.dataHash === attestation.blockHash);
+  if (attested?.block !== void 0) {
+    const carried = attested.block.step_hashes?.[level];
+    return carried === attestation.stepHash ? verdict("provably-invalid", "the block carries the step hash the attestation names at that level", transcript) : verdict("verified", "the attested block says something else at that level", {
+      ...transcript,
+      blockStepHashes: attested.block.step_hashes ?? [],
+      carried: carried ?? null
+    });
+  }
+  const age = ctx.submission.requestCarryingHeight - attestation.blockNumber;
+  if (age > ctx.params.evidenceRetentionXl1Blocks) {
+    return verdict("indeterminate", `the attested block is ${age} blocks back, past the retention window`, transcript);
+  }
+  const finalized = await ctx.chain.blockAtHeight(attestation.blockNumber);
+  if (finalized === void 0) {
+    return verdict("indeterminate", "the attested height is not resolvable on this canonical chain", transcript);
+  }
+  const finalizedHash = finalized[0]._dataHash;
+  return finalizedHash === attestation.blockHash ? verdict("provably-invalid", "the attested block is the one finalized at that height", transcript) : verdict(
+    "verified",
+    "no block with the attested hash was finalized at that height",
+    { ...transcript, finalizedHash: finalizedHash ?? null },
+    true
+  );
+};
+
+// src/modules/slashing/verify/verifyIneligibleProduction.ts
+import { asBlockBoundWitness as asBlockBoundWitness4, isTimePayload as isTimePayload2 } from "@xyo-network/xl1-sdk";
+async function anchorOf(block, artifacts) {
+  for (const artifact of artifacts.values()) {
+    if (!isTimePayload2(artifact.payload)) continue;
+    for (const carried of block.payload_hashes) {
+      if (await referencesArtifact(carried, artifact)) return artifact.payload.ethereum;
+    }
+  }
+  return void 0;
+}
+var blockAt = (height, artifacts) => [...artifacts.values()].map((artifact) => asBlockBoundWitness4(artifact.payload)).find((block) => block?.block === height);
+async function blockByReference(reference, artifacts) {
+  if (reference === null) return void 0;
+  for (const artifact of artifacts.values()) {
+    const block = asBlockBoundWitness4(artifact.payload);
+    if (block === void 0) continue;
+    if (await referencesArtifact(reference, artifact)) return block;
+  }
+  return void 0;
+}
+var verifyIneligibleProduction = async (ctx, request, artifacts) => {
+  const accused = blockAt(request.block, artifacts);
+  const parent = accused === void 0 ? void 0 : await blockByReference(accused.previous, artifacts);
+  if (accused === void 0 || parent === void 0) {
+    return verdict("provably-invalid", "the accused block and its signed parent were not both cited");
+  }
+  if (!accused.addresses.includes(request.accused)) {
+    return verdict("provably-invalid", "the accused did not sign the cited block");
+  }
+  const blockAnchor = await anchorOf(accused, artifacts);
+  const parentAnchor = await anchorOf(parent, artifacts);
+  if (blockAnchor === void 0 || parentAnchor === void 0) {
+    return verdict("indeterminate", "the blocks do not both carry an anchor to measure against");
+  }
+  const evaluation = await evaluateProducerEligibility({
+    accused: request.accused,
+    blockAnchor,
+    height: request.block,
+    intent: () => accused.addresses.includes(request.accused),
+    params: ctx.params,
+    parentAnchor,
+    snapshot: ctx.snapshot
+  });
+  const transcript = {
+    accused: request.accused,
+    blockAnchor,
+    eStar: evaluation.eStar ?? null,
+    parentAnchor
+  };
+  if (request.evm !== evaluation.eStar) {
+    return verdict("provably-invalid", `the report measures at ${request.evm}, but the rule measures at ${evaluation.eStar}`, transcript);
+  }
+  if (!evaluation.resolvable) {
+    return verdict("indeterminate", "no stake snapshot, so standing cannot be measured", transcript);
+  }
+  const measured = {
+    ...transcript,
+    seasonedActive: evaluation.activeStake?.toString() ?? null,
+    seasonedSelfBond: evaluation.selfBond?.toString() ?? null
+  };
+  return evaluation.eligible === true ? verdict("provably-invalid", "the accused met every participation requirement at that point", measured) : verdict("verified", `the accused was ineligible at that point: ${evaluation.reason}`, { ...measured, reason: evaluation.reason ?? null });
+};
+
+// src/modules/slashing/verify/verifyInvalidBlock.ts
+import { asBlockBoundWitness as asBlockBoundWitness5, BlockCumulativeBalanceValidatorFactory } from "@xyo-network/xl1-sdk";
+import { validateBlock } from "#validation";
+function citedHydratedBlock(artifacts) {
+  const cited = [...artifacts.values()];
+  const entry = cited.find((artifact) => asBlockBoundWitness5(artifact.payload) !== void 0);
+  const block = entry === void 0 ? void 0 : asBlockBoundWitness5(entry.payload);
+  return block === void 0 ? void 0 : { block, payloads: cited.filter((artifact) => artifact !== entry).map((artifact) => artifact.payload) };
+}
+async function replayStateRules(ctx, cited, transcript) {
+  if (ctx.balances === void 0) {
+    return verdict("indeterminate", "no balance view, so state rules cannot be replayed", transcript);
+  }
+  const errors = await BlockCumulativeBalanceValidatorFactory()(
+    {
+      accountBalance: ctx.balances,
+      chainIdAtBlockNumber: () => cited.block.chain,
+      singletons: {}
+    },
+    [cited.block, cited.payloads]
+  );
+  return errors.length > 0 ? verdict("verified", `the cited block breaks a state rule: ${errors[0]?.message}`, {
+    ...transcript,
+    errors: errors.map((error) => error.message),
+    rule: "state"
+  }) : verdict("provably-invalid", "the cited block satisfies every rule this procedure can replay", transcript);
+}
+var verifyInvalidBlock = async (ctx, request, artifacts) => {
+  const cited = citedHydratedBlock(artifacts);
+  if (cited === void 0) return verdict("provably-invalid", "no block among the cited artifacts");
+  const transcript = {
+    accused: request.accused,
+    block: cited.block.block,
+    catalogVersion: ctx.catalogVersion,
+    payloadCount: cited.payloads.length
+  };
+  if (cited.block.block !== request.block) {
+    return verdict("provably-invalid", "the cited block is not at the height the report names", transcript);
+  }
+  if (!cited.block.addresses.includes(request.accused)) {
+    return verdict("provably-invalid", "the accused did not sign the cited block", transcript);
+  }
+  const protocolErrors = await validateBlock({ singletons: {} }, cited.block, cited.block.chain);
+  if (protocolErrors.length > 0) {
+    return verdict("verified", `the cited block breaks a protocol rule: ${protocolErrors[0]?.message}`, {
+      ...transcript,
+      errors: protocolErrors.map((error) => error.message),
+      rule: "protocol"
+    });
+  }
+  if (cited.block.previous === null) {
+    return verdict("provably-invalid", "the cited block is a genesis block, which has no parent to judge it against", transcript);
+  }
+  const parent = await ctx.chain.blockByHash(cited.block.previous);
+  if (parent === void 0) {
+    return verdict("indeterminate", "the parent is not resolvable on this canonical chain", transcript);
+  }
+  if (cited.block.block !== parent[0].block + 1) {
+    return verdict("verified", "the cited block does not follow its own parent in height", {
+      ...transcript,
+      parentBlock: parent[0].block,
+      rule: "height"
+    });
+  }
+  return await replayStateRules(ctx, cited, transcript);
+};
+
+// src/modules/slashing/verify/verifyInvalidSlashRequest.ts
+import { isSlashRequest as isSlashRequest2 } from "@xyo-network/xl1-sdk";
+var inverted = {
+  "indeterminate": "indeterminate",
+  "provably-invalid": "verified",
+  "verified": "provably-invalid"
+};
+function createVerifyInvalidSlashRequest(resolve) {
+  return async (ctx, request, artifacts) => {
+    const accused = artifacts.values().find((artifact) => isSlashRequest2(artifact.payload));
+    if (accused === void 0) {
+      return verdict("provably-invalid", "no slash request among the cited artifacts");
+    }
+    const original = accused.payload;
+    const key = offenseKeyOf(original);
+    const finalized = (await ctx.history.requestsByKey(key)).find((candidate) => candidate.hash === accused.dataHash);
+    if (finalized === void 0) {
+      return verdict("indeterminate", "the accused request is not visible in finalized history");
+    }
+    const transcript = {
+      accusedRequest: accused.dataHash,
+      innerOffense: original.offense,
+      originalCarryingHeight: finalized.carryingHeight,
+      reporter: request.accused
+    };
+    const adjudication = await ctx.history.adjudicationByKey(key);
+    if (adjudication !== void 0) {
+      if (adjudication.carryingHeight >= finalized.carryingHeight) {
+        return verdict("provably-invalid", "timing-excused: the offense was not yet adjudicated when the report was filed", { ...transcript, adjudicationHeight: adjudication.carryingHeight });
+      }
+      return verdict("verified", "re-litigation: the offense was already adjudicated on-chain when the report was filed", { ...transcript, adjudicationHeight: adjudication.carryingHeight });
+    }
+    const procedure = resolve()[original.offense];
+    if (procedure === void 0) {
+      return verdict("indeterminate", `no verification procedure for the inner offense '${original.offense}'`, transcript);
+    }
+    const innerCtx = {
+      ...ctx,
+      catalogVersion: original.catalog,
+      submission: { requestCarryingHeight: finalized.carryingHeight }
+    };
+    const innerArtifacts = await verifyArtifacts(ctx.artifacts, original.evidence);
+    if (!innerArtifacts.ok) {
+      return innerArtifacts.missing === true ? verdict("indeterminate", `the original's evidence is not available to re-run: ${innerArtifacts.reason}`, transcript) : verdict("verified", `the original's evidence fails the preamble: ${innerArtifacts.reason}`, transcript);
+    }
+    const innerFreshness = await freshnessGate(innerCtx, original);
+    const innerVerdict = innerFreshness.verdict ?? await procedure(innerCtx, original, innerArtifacts.byHash);
+    return verdict(
+      inverted[innerVerdict.outcome],
+      `the original report verified as '${innerVerdict.outcome}': ${innerVerdict.reason}`,
+      {
+        ...transcript,
+        inner: innerVerdict.transcript,
+        innerOutcome: innerVerdict.outcome
+      }
+    );
+  };
+}
+
+// src/modules/slashing/verify/verifyRewardOvermint.ts
+import { hexToBigInt } from "@ariestools/sdk";
+import {
+  asBlockBoundWitness as asBlockBoundWitness6,
+  isTransferPayload,
+  rewardFromBlockNumber,
+  XYO_ZERO_ADDRESS
+} from "@xyo-network/xl1-sdk";
+function mintedBy(payloads) {
+  return payloads.filter((payload) => isTransferPayload(payload)).filter((transfer) => transfer.from === XYO_ZERO_ADDRESS).reduce((total, transfer) => total + Object.values(transfer.transfers).reduce((sum, amount) => sum + hexToBigInt(amount), 0n), 0n);
+}
+async function allowedEmission(ctx, blockNumber, parentAnchor) {
+  if (ctx.params.rewardSource === "schedule") return rewardFromBlockNumber(blockNumber);
+  if (parentAnchor === void 0 || ctx.blockRewardAt === void 0) return void 0;
+  return await ctx.blockRewardAt(parentAnchor);
+}
+var verifyRewardOvermint = async (ctx, request, artifacts) => {
+  const cited = [...artifacts.values()];
+  const entry = cited.find((artifact) => asBlockBoundWitness6(artifact.payload) !== void 0);
+  const block = entry === void 0 ? void 0 : asBlockBoundWitness6(entry.payload);
+  if (block === void 0) return verdict("provably-invalid", "no block among the cited artifacts");
+  if (block.block !== request.block) {
+    return verdict("provably-invalid", "the cited block is not at the height the report names");
+  }
+  if (!block.addresses.includes(request.accused)) {
+    return verdict("provably-invalid", "the accused did not sign the cited block");
+  }
+  const payloads = cited.filter((artifact) => artifact !== entry).map((artifact) => artifact.payload);
+  const minted = mintedBy(payloads);
+  const parentAnchor = block.previous === null ? void 0 : await ctx.chain.validatedAnchorAt(block.block - 1);
+  const allowed = await allowedEmission(ctx, block.block, parentAnchor);
+  const transcript = {
+    accused: request.accused,
+    allowed: allowed === void 0 ? null : allowed.toString(),
+    block: block.block,
+    minted: minted.toString(),
+    parentAnchor: parentAnchor ?? null,
+    rewardSource: ctx.params.rewardSource
+  };
+  if (allowed === void 0) {
+    return verdict("indeterminate", "the allowed emission for this block cannot be established", transcript);
+  }
+  return minted > allowed ? verdict("verified", `the block minted ${minted} against an allowance of ${allowed}`, transcript) : verdict("provably-invalid", `the block minted ${minted}, within its allowance of ${allowed}`, transcript);
+};
+
+// src/modules/slashing/verify/verifyOffense.ts
+var offenseProcedures = {
+  "equivocation": verifyEquivocation,
+  "false-anchor": verifyFalseAnchor,
+  "false-attestation": verifyFalseAttestation,
+  "ineligible-production": verifyIneligibleProduction,
+  "invalid-block": verifyInvalidBlock,
+  "invalid-slash-request": createVerifyInvalidSlashRequest(() => offenseProcedures),
+  "reward-overmint": verifyRewardOvermint
+};
+async function verifyOffense(ctx, request) {
+  const artifacts = await verifyArtifacts(ctx.artifacts, request.evidence);
+  if (!artifacts.ok) {
+    return verdict(artifacts.missing === true ? "indeterminate" : "provably-invalid", artifacts.reason, { stage: "artifacts" });
+  }
+  const freshness = await freshnessGate(ctx, request);
+  if (freshness.verdict !== void 0) return freshness.verdict;
+  const procedure = offenseProcedures[request.offense];
+  if (procedure === void 0) {
+    return verdict("indeterminate", `no verification procedure for '${request.offense}'`, { catalogVersion: ctx.catalogVersion, offense: request.offense });
+  }
+  const result = await procedure(ctx, request, artifacts.byHash);
+  return {
+    ...result,
+    transcript: {
+      ...result.transcript,
+      eOff: freshness.eOff ?? null,
+      eSub: freshness.eSub ?? null,
+      offense: request.offense
+    }
+  };
+}
+export {
+  SlashIndexStoreMoniker,
+  VerificationOutcomes,
+  canonicalOffenseHeight,
+  createVerifyInvalidSlashRequest,
+  evaluateProducerEligibility,
+  findCandidatePairs,
+  foldSlashIndex,
+  freshnessGate,
+  isOffenseWatchable,
+  isSlashIndexStore,
+  mergeKeyRecord,
+  offenseKeyOf,
+  offenseKeyString,
+  offenseProcedures,
+  referencesArtifact,
+  suppressionFor,
+  verdict,
+  verifyArtifacts,
+  verifyEquivocation,
+  verifyFalseAnchor,
+  verifyFalseAttestation,
+  verifyIneligibleProduction,
+  verifyInvalidBlock,
+  verifyOffense,
+  verifyRewardOvermint
+};
+//# sourceMappingURL=slashing.mjs.map