@xyo-network/xl1-protocol 5.1.3 → 5.2.0

package/dist/neutral/protocol-model.mjs

@@ -6,7 +6,7 @@ import {
   isSchemaPayload,
   SchemaSchema
 } from "@xyo-network/sdk";
-import { z as z27 } from "zod";
+import { z as z33 } from "zod";
 
 // src/modules/protocol-model/payload/application/Exchange/ExchangeOutcome.ts
 import { AsObjectFactory, HashZod } from "@ariestools/sdk";
@@ -676,16 +676,148 @@ var isTimePayload = (value) => {
 var asTimePayload = AsObjectFactory15.create(isTimePayload);
 var asTimePayloadWithStorageMeta = AsObjectFactory15.create(isTimePayload);
 
+// src/modules/protocol-model/payload/slash/SlashAdjudicationPayload.ts
+import { AsObjectFactory as AsObjectFactory16, HashZod as HashZod5 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema16,
+  isPayloadOfZodType as isPayloadOfZodType12,
+  XyoAddressZod as XyoAddressZod5
+} from "@xyo-network/sdk";
+import { z as z24 } from "zod/mini";
+var SlashOutcomes = ["confirmed", "refuted", "indeterminate", "invalid"];
+var SlashOutcomeZod = z24.literal(SlashOutcomes);
+var SlashAdjudicationSchema = asSchema16("network.xyo.chain.slash.adjudication", true);
+var SlashAdjudicationFieldsZod = z24.object({
+  /** Address credited with the report, required once bounties are paid. */
+  claimant: z24.optional(XyoAddressZod5),
+  /** Hash of the commitment that won the claim. */
+  claimantCommit: z24.optional(HashZod5),
+  /** Address issuing the adjudication. */
+  from: XyoAddressZod5,
+  /** How the request was resolved. */
+  outcome: SlashOutcomeZod,
+  /** Why, for any outcome other than confirmed. */
+  reason: z24.optional(z24.string()),
+  /** Hash of the request being adjudicated. */
+  request: HashZod5
+});
+var isSlashAdjudication = isPayloadOfZodType12(
+  SlashAdjudicationFieldsZod,
+  SlashAdjudicationSchema
+);
+var asSlashAdjudication = AsObjectFactory16.create(isSlashAdjudication);
+
+// src/modules/protocol-model/payload/slash/SlashChallengePayload.ts
+import { AsObjectFactory as AsObjectFactory17, HashZod as HashZod6 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema17,
+  isPayloadOfZodType as isPayloadOfZodType13,
+  XyoAddressZod as XyoAddressZod6
+} from "@xyo-network/sdk";
+import { z as z25 } from "zod/mini";
+var SlashChallengeSchema = asSchema17("network.xyo.chain.slash.challenge", true);
+var SlashChallengeFieldsZod = z25.object({
+  /** Hashes of the counter-artifacts, carried in accompanying evidence payloads. */
+  evidence: z25.array(HashZod6),
+  /** Address filing the challenge. */
+  from: XyoAddressZod6,
+  /** Hash of the request being challenged. */
+  request: HashZod6
+});
+var isSlashChallenge = isPayloadOfZodType13(SlashChallengeFieldsZod, SlashChallengeSchema);
+var asSlashChallenge = AsObjectFactory17.create(isSlashChallenge);
+
+// src/modules/protocol-model/payload/slash/SlashCommitPayload.ts
+import { AsObjectFactory as AsObjectFactory18, HashZod as HashZod7 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema18,
+  isPayloadOfZodType as isPayloadOfZodType14,
+  XyoAddressZod as XyoAddressZod7
+} from "@xyo-network/sdk";
+import { z as z26 } from "zod/mini";
+var SlashCommitSchema = asSchema18("network.xyo.chain.slash.commit", true);
+var SlashCommitFieldsZod = z26.object({
+  /** Hash of the report this commitment reserves. */
+  commitment: HashZod7,
+  /** Address that will file the report. */
+  from: XyoAddressZod7
+});
+var isSlashCommit = isPayloadOfZodType14(SlashCommitFieldsZod, SlashCommitSchema);
+var asSlashCommit = AsObjectFactory18.create(isSlashCommit);
+
+// src/modules/protocol-model/payload/slash/SlashEvidencePayload.ts
+import { AsObjectFactory as AsObjectFactory19 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema19,
+  isPayloadOfZodType as isPayloadOfZodType15,
+  XyoAddressZod as XyoAddressZod8
+} from "@xyo-network/sdk";
+import { z as z27 } from "zod/mini";
+var SlashEvidenceSchema = asSchema19("network.xyo.chain.slash.evidence", true);
+var SlashEvidenceFieldsZod = z27.object({
+  /** The signed artifacts, exactly as they were observed. */
+  artifacts: z27.array(z27.record(z27.string(), z27.unknown())),
+  /** Address that submitted the evidence. */
+  from: XyoAddressZod8
+});
+var isSlashEvidence = isPayloadOfZodType15(SlashEvidenceFieldsZod, SlashEvidenceSchema);
+var asSlashEvidence = AsObjectFactory19.create(isSlashEvidence);
+
+// src/modules/protocol-model/payload/slash/SlashRequestPayload.ts
+import { AsObjectFactory as AsObjectFactory20, HashZod as HashZod8 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema20,
+  isPayloadOfZodType as isPayloadOfZodType16,
+  XyoAddressZod as XyoAddressZod9
+} from "@xyo-network/sdk";
+import { z as z29 } from "zod/mini";
+
+// src/modules/protocol-model/model/OffenseCode.ts
+import { z as z28 } from "zod/mini";
+var OffenseCodes = [
+  "equivocation",
+  "invalid-block",
+  "reward-overmint",
+  "false-anchor",
+  "ineligible-production",
+  "invalid-slash-request",
+  "false-attestation"
+];
+var OffenseCodeZod = z28.literal(OffenseCodes);
+
+// src/modules/protocol-model/payload/slash/SlashRequestPayload.ts
+var SlashRequestSchema = asSchema20("network.xyo.chain.slash.request", true);
+var SlashRequestFieldsZod = z29.object({
+  /** Address accused of the offense. */
+  accused: XyoAddressZod9,
+  /** Height the offense occurred at. */
+  block: XL1BlockNumberZod,
+  /** Catalog version the offense is judged under. */
+  catalog: z29.number().check(z29.multipleOf(1), z29.positive()),
+  /** Chain the offense occurred on. */
+  chain: ChainIdZod,
+  /** Hashes of the artifacts proving the offense, carried in accompanying evidence payloads. */
+  evidence: z29.array(HashZod8),
+  /** EVM height the claim is judged against, for anchor and eligibility offenses. */
+  evm: z29.optional(z29.number()),
+  /** Address filing the report. */
+  from: XyoAddressZod9,
+  /** Offense class being alleged. */
+  offense: OffenseCodeZod
+});
+var isSlashRequest = isPayloadOfZodType16(SlashRequestFieldsZod, SlashRequestSchema);
+var asSlashRequest = AsObjectFactory20.create(isSlashRequest);
+
 // src/modules/protocol-model/payload/StepIdentityPayload.ts
-import { AsObjectFactory as AsObjectFactory16 } from "@ariestools/sdk";
-import { asSchema as asSchema16, isPayloadOfZodType as isPayloadOfZodType12 } from "@xyo-network/sdk";
+import { AsObjectFactory as AsObjectFactory21 } from "@ariestools/sdk";
+import { asSchema as asSchema21, isPayloadOfZodType as isPayloadOfZodType17 } from "@xyo-network/sdk";
 
 // src/modules/protocol-model/Step/StepIdentity.ts
 import { isUndefined } from "@ariestools/sdk";
-import { z as z24 } from "zod";
-var StepIdentityZod = z24.object({
+import { z as z30 } from "zod";
+var StepIdentityZod = z30.object({
   block: XL1BlockNumberZod.describe("The block number at which the step occurs"),
-  step: z24.number().int().nonnegative().describe("The index of the step into the StepSize array")
+  step: z30.number().int().nonnegative().describe("The index of the step into the StepSize array")
 });
 function tryParseInt(value) {
   if (value === "") return void 0;
@@ -751,33 +883,33 @@ var StepRewardFractions = [
 ];
 
 // src/modules/protocol-model/payload/StepIdentityPayload.ts
-var StepIdentitySchema = asSchema16("network.xyo.chain.step.identity", true);
-var isStepIdentityPayload = isPayloadOfZodType12(StepIdentityZod, StepIdentitySchema);
-var asStepIdentityPayload = AsObjectFactory16.create(isStepIdentityPayload);
+var StepIdentitySchema = asSchema21("network.xyo.chain.step.identity", true);
+var isStepIdentityPayload = isPayloadOfZodType17(StepIdentityZod, StepIdentitySchema);
+var asStepIdentityPayload = AsObjectFactory21.create(isStepIdentityPayload);
 
 // src/modules/protocol-model/payload/StepWitness.ts
-import { AsObjectFactory as AsObjectFactory17, HashZod as HashZod5 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory22, HashZod as HashZod9 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema17,
-  isPayloadOfZodType as isPayloadOfZodType13,
-  XyoAddressZod as XyoAddressZod5
+  asSchema as asSchema22,
+  isPayloadOfZodType as isPayloadOfZodType18,
+  XyoAddressZod as XyoAddressZod10
 } from "@xyo-network/sdk";
-import { z as z25 } from "zod/mini";
-var StepWitnessSchema = asSchema17("network.xyo.chain.validation.step.witness", true);
-var StepWitnessFieldsZod = z25.object({
+import { z as z31 } from "zod/mini";
+var StepWitnessSchema = asSchema22("network.xyo.chain.validation.step.witness", true);
+var StepWitnessFieldsZod = z31.object({
   /** Hash of the block in which the step hash was observed */
-  blockHash: HashZod5,
+  blockHash: HashZod9,
   /** Block number of the block in which the step hash was observed */
   blockNumber: XL1BlockNumberZod,
   /** The observed step hash — the entry at the step level's index in the block's step_hashes */
-  stepHash: HashZod5,
+  stepHash: HashZod9,
   /** Block-interval size of the observed step level — must be one of StepSizes */
-  stepSize: z25.literal(StepSizes),
+  stepSize: z31.literal(StepSizes),
   /** Address of the observer */
-  witness: XyoAddressZod5
+  witness: XyoAddressZod10
 });
-var isStepWitness = isPayloadOfZodType13(StepWitnessFieldsZod, StepWitnessSchema);
-var asStepWitness = AsObjectFactory17.create(isStepWitness);
+var isStepWitness = isPayloadOfZodType18(StepWitnessFieldsZod, StepWitnessSchema);
+var asStepWitness = AsObjectFactory22.create(isStepWitness);
 
 // src/modules/protocol-model/transaction/TransactionGasCosts.ts
 var TransactionGasCosts = {
@@ -798,32 +930,32 @@ var TransactionGasCosts = {
 
 // src/modules/protocol-model/TransferPayload.ts
 import {
-  AsObjectFactory as AsObjectFactory18,
+  AsObjectFactory as AsObjectFactory23,
   HexZod as HexZod6,
   JsonObjectZod,
   zodIsFactory as zodIsFactory4
 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema18,
+  asSchema as asSchema23,
   isPayloadOfSchemaType as isPayloadOfSchemaType5,
   PayloadZodOfSchema as PayloadZodOfSchema2,
-  XyoAddressZod as XyoAddressZod6
+  XyoAddressZod as XyoAddressZod11
 } from "@xyo-network/sdk";
-import { z as z26 } from "zod/mini";
-var TransferSchema = asSchema18("network.xyo.transfer", true);
-var TransferFieldsZod = z26.object({
+import { z as z32 } from "zod/mini";
+var TransferSchema = asSchema23("network.xyo.transfer", true);
+var TransferFieldsZod = z32.object({
   // Removed as only transaction have opCodes
   // $opCodes: z.array(z.string()).optional(),
-  context: z26.optional(JsonObjectZod),
-  epoch: z26.number(),
-  from: XyoAddressZod6,
-  transfers: z26.record(XyoAddressZod6, HexZod6)
+  context: z32.optional(JsonObjectZod),
+  epoch: z32.number(),
+  from: XyoAddressZod11,
+  transfers: z32.record(XyoAddressZod11, HexZod6)
 });
-var TransferZod = z26.extend(PayloadZodOfSchema2(TransferSchema), TransferFieldsZod.shape);
+var TransferZod = z32.extend(PayloadZodOfSchema2(TransferSchema), TransferFieldsZod.shape);
 var isTransfer = isPayloadOfSchemaType5(TransferSchema);
 var isTransferPayload = zodIsFactory4(TransferZod);
-var asTransfer = AsObjectFactory18.create(isTransfer);
-var asTransferPayload = AsObjectFactory18.create(isTransferPayload);
+var asTransfer = AsObjectFactory23.create(isTransfer);
+var asTransferPayload = AsObjectFactory23.create(isTransferPayload);
 
 // src/modules/protocol-model/block/AllowedBlockPayload.ts
 var AllowedBlockPayloadSchemas = [
@@ -834,14 +966,20 @@ var AllowedBlockPayloadSchemas = [
   ChainStakeIntentSchema,
   HashSchema,
   SchemaSchema,
+  SlashAdjudicationSchema,
+  SlashChallengeSchema,
+  SlashCommitSchema,
+  SlashEvidenceSchema,
+  SlashRequestSchema,
   StepCompleteSchema,
+  StepWitnessSchema,
   TimeSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadSchemaZod = z27.enum(AllowedBlockPayloadSchemas);
+var AllowedBlockPayloadSchemaZod = z33.enum(AllowedBlockPayloadSchemas);
 var isAllowedBlockPayloadSchema = zodIsFactory5(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (value) => {
-  return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isStepComplete(value) || isTimePayload(value) || isTransactionBoundWitness(value);
+  return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isSlashAdjudication(value) || isSlashChallenge(value) || isSlashCommit(value) || isSlashEvidence(value) || isSlashRequest(value) || isStepWitness(value) || isStepComplete(value) || isTimePayload(value) || isTransactionBoundWitness(value);
 };
 var isAllowedBlockPayloadWithHashMeta = (value) => {
   return isAllowedBlockPayload(value) && isHashMeta(value);
@@ -849,7 +987,7 @@ var isAllowedBlockPayloadWithHashMeta = (value) => {
 
 // src/modules/protocol-model/block/BlockBoundWitness.ts
 import {
-  HashZod as HashZod6,
+  HashZod as HashZod10,
   zodAsFactory as zodAsFactory7,
   zodIsFactory as zodIsFactory6,
   zodToFactory as zodToFactory7
@@ -859,16 +997,24 @@ import {
   WithHashMetaZod as WithHashMetaZod2,
   WithStorageMetaZod as WithStorageMetaZod2
 } from "@xyo-network/sdk";
-import { z as z28 } from "zod/mini";
-var BlockBoundWitnessFieldsZod = z28.object({
+import { z as z34 } from "zod/mini";
+var BlockBoundWitnessFieldsZod = z34.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: z28.nullable(HashZod6),
-  protocol: z28.optional(z28.number()),
-  step_hashes: z28.optional(z28.array(HashZod6))
+  previous: z34.nullable(HashZod10),
+  protocol: z34.optional(z34.number()),
+  step_hashes: z34.optional(z34.array(HashZod10)),
+  /**
+   * Signed hash of the same-height candidate this block replaces.
+   *
+   * Sits in the signed fields rather than the metadata deliberately: it is what separates an
+   * honest re-proposal from double-signing, and a producer must not be able to add or drop it
+   * after the fact.
+   */
+  supersedes: z34.optional(HashZod10)
 });
-var BlockBoundWitnessMetaZod = z28.object({ $epoch: z28.number() });
-var BlockBoundWitnessZod = z28.object({
+var BlockBoundWitnessMetaZod = z34.object({ $epoch: z34.number() });
+var BlockBoundWitnessZod = z34.object({
   ...BoundWitnessZod2.shape,
   ...BlockBoundWitnessFieldsZod.shape,
   ...BlockBoundWitnessMetaZod.shape
@@ -897,7 +1043,7 @@ import {
   WithHashMetaZod as WithHashMetaZod4,
   WithStorageMetaZod as WithStorageMetaZod4
 } from "@xyo-network/sdk";
-import { z as z32 } from "zod/mini";
+import { z as z38 } from "zod/mini";
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitness.ts
 import {
@@ -906,9 +1052,9 @@ import {
   zodToFactory as zodToFactory8
 } from "@ariestools/sdk";
 import { SignedBoundWitnessZod as SignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z29 } from "zod/mini";
-var SignedBlockBoundWitnessZod = z29.safeExtend(
-  z29.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z35 } from "zod/mini";
+var SignedBlockBoundWitnessZod = z35.safeExtend(
+  z35.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
 var isSignedBlockBoundWitness = zodIsFactory7(SignedBlockBoundWitnessZod);
@@ -922,13 +1068,13 @@ import {
   zodToFactory as zodToFactory9
 } from "@ariestools/sdk";
 import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk";
-import { z as z30 } from "zod/mini";
+import { z as z36 } from "zod/mini";
 var SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod3(SignedBlockBoundWitnessZod);
 var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory8(SignedBlockBoundWitnessWithHashMetaZod);
 var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory9(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
-var SignedBlockBoundWitnessWithHashMetaishZod = z30.pipe(
+var SignedBlockBoundWitnessWithHashMetaishZod = z36.pipe(
   SignedBlockBoundWitnessZod,
-  z30.transform(async (data) => {
+  z36.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithHashMeta(data)) {
       return data;
     }
@@ -947,16 +1093,16 @@ import {
   zodToFactory as zodToFactory10
 } from "@ariestools/sdk";
 import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod3 } from "@xyo-network/sdk";
-import { z as z31 } from "zod/mini";
+import { z as z37 } from "zod/mini";
 var SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod3(SignedBlockBoundWitnessZod);
 var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory9(SignedBlockBoundWitnessWithStorageMetaZod);
 var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory10(
   SignedBlockBoundWitnessWithStorageMetaZod,
   "asSignedBlockBoundWitnessWithStorageMeta"
 );
-var SignedBlockBoundWitnessWithStorageMetaishZod = z31.pipe(
+var SignedBlockBoundWitnessWithStorageMetaishZod = z37.pipe(
   SignedBlockBoundWitnessZod,
-  z31.transform(async (data) => {
+  z37.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
       return data;
     }
@@ -972,62 +1118,62 @@ var toSignedBlockBoundWitnessWithStorageMeta = zodToFactory10(
 );
 
 // src/modules/protocol-model/block/HydratedBlock.ts
-var HydratedBlockZod = z32.tuple([
+var HydratedBlockZod = z38.tuple([
   BlockBoundWitnessZod,
-  z32.array(PayloadZodLoose)
+  z38.array(PayloadZodLoose)
 ]);
 var isHydratedBlock = zodIsFactory10(HydratedBlockZod);
 var asHydratedBlock = zodAsFactory11(HydratedBlockZod, "asHydratedBlock");
 var toHydratedBlock = zodToFactory11(HydratedBlockZod, "toHydratedBlock");
-var HydratedBlockWithHashMetaZod = z32.tuple([
+var HydratedBlockWithHashMetaZod = z38.tuple([
   WithHashMetaZod4(BlockBoundWitnessZod),
-  z32.array(z32.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z38.array(z38.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
 var isHydratedBlockWithHashMeta = zodIsFactory10(HydratedBlockWithHashMetaZod);
 var asHydratedBlockWithHashMeta = zodAsFactory11(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
 var toHydratedBlockWithHashMeta = zodToFactory11(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
-var HydratedBlockWithStorageMetaZod = z32.tuple([
+var HydratedBlockWithStorageMetaZod = z38.tuple([
   WithStorageMetaZod4(BlockBoundWitnessZod),
-  z32.array(z32.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z38.array(z38.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 var isHydratedBlockWithStorageMeta = zodIsFactory10(HydratedBlockWithStorageMetaZod);
 var asHydratedBlockWithStorageMeta = zodAsFactory11(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
 var toHydratedBlockWithStorageMeta = zodToFactory11(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
-var SignedHydratedBlockZod = z32.tuple([
+var SignedHydratedBlockZod = z38.tuple([
   SignedBlockBoundWitnessZod,
-  z32.array(z32.looseObject(PayloadZod.shape))
+  z38.array(z38.looseObject(PayloadZod.shape))
 ]);
 var isSignedHydratedBlock = zodIsFactory10(SignedHydratedBlockZod);
 var asSignedHydratedBlock = zodAsFactory11(SignedHydratedBlockZod, "asSignedHydratedBlock");
 var toSignedHydratedBlock = zodToFactory11(SignedHydratedBlockZod, "toSignedHydratedBlock");
-var SignedHydratedBlockToJsonZod = z32.tuple([
+var SignedHydratedBlockToJsonZod = z38.tuple([
   SignedBlockBoundWitnessZod,
-  z32.array(z32.looseObject(PayloadZod.shape))
+  z38.array(z38.looseObject(PayloadZod.shape))
 ]);
 var isSignedHydratedBlockToJson = zodIsFactory10(SignedHydratedBlockToJsonZod);
 var asSignedHydratedBlockToJson = zodAsFactory11(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
 var toSignedHydratedBlockToJson = zodToFactory11(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
-var SignedHydratedBlockWithHashMetaZod = z32.tuple([
+var SignedHydratedBlockWithHashMetaZod = z38.tuple([
   WithHashMetaZod4(SignedBlockBoundWitnessZod),
-  z32.array(z32.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z38.array(z38.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var SignedHydratedBlockWithHashMetaishZod = z32.tuple([
-  z32.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
-  z32.array(z32.looseObject(WithHashMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithHashMetaishZod = z38.tuple([
+  z38.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
+  z38.array(z38.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
 var isSignedHydratedBlockWithHashMeta = zodIsFactory10(SignedHydratedBlockWithHashMetaZod);
 var asSignedHydratedBlockWithHashMeta = zodAsFactory11(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
 var toSignedHydratedBlockWithHashMeta = zodToFactory11(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
-var SignedHydratedBlockWithStorageMetaZod = z32.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z38.tuple([
   WithStorageMetaZod4(SignedBlockBoundWitnessZod),
-  z32.array(z32.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z38.array(z38.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 var isSignedHydratedBlockWithStorageMeta = zodIsFactory10(SignedHydratedBlockWithStorageMetaZod);
 var asSignedHydratedBlockWithStorageMeta = zodAsFactory11(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
 var toSignedHydratedBlockWithStorageMeta = zodToFactory11(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
-var SignedHydratedBlockWithStorageMetaishZod = z32.tuple([
-  z32.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
-  z32.array(z32.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithStorageMetaishZod = z38.tuple([
+  z38.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
+  z38.array(z38.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 
 // src/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.ts
@@ -1037,9 +1183,9 @@ import {
   zodToFactory as zodToFactory12
 } from "@ariestools/sdk";
 import { UnsignedBoundWitnessZod as UnsignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z33 } from "zod/mini";
-var UnsignedBlockBoundWitnessZod = z33.safeExtend(
-  z33.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z39 } from "zod/mini";
+var UnsignedBlockBoundWitnessZod = z39.safeExtend(
+  z39.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
 var isUnsignedBlockBoundWitness = zodIsFactory11(UnsignedBlockBoundWitnessZod);
@@ -1047,53 +1193,53 @@ var asUnsignedBlockBoundWitness = zodAsFactory12(UnsignedBlockBoundWitnessZod, "
 var toUnsignedBlockBoundWitness = zodToFactory12(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
 
 // src/modules/protocol-model/evidence/CandidatePairPayload.ts
-import { AsObjectFactory as AsObjectFactory19, HashZod as HashZod7 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory24, HashZod as HashZod11 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema19,
-  isPayloadOfZodType as isPayloadOfZodType14,
-  XyoAddressZod as XyoAddressZod7
+  asSchema as asSchema24,
+  isPayloadOfZodType as isPayloadOfZodType19,
+  XyoAddressZod as XyoAddressZod12
 } from "@xyo-network/sdk";
-import { z as z34 } from "zod/mini";
-var CandidatePairSchema = asSchema19("network.xyo.chain.evidence.candidate.pair", true);
-var CandidatePairFieldsZod = z34.object({
+import { z as z40 } from "zod/mini";
+var CandidatePairSchema = asSchema24("network.xyo.chain.evidence.candidate.pair", true);
+var CandidatePairFieldsZod = z40.object({
   /** Chain both candidates were proposed on */
   chain: ChainIdZod,
   /** Block number both candidates claim */
   height: XL1BlockNumberZod,
   /** Address that signed both candidates */
-  producer: XyoAddressZod7,
+  producer: XyoAddressZod12,
   /** The two candidates' recomputed bound witness data hashes, sorted ascending */
-  subjects: z34.tuple([HashZod7, HashZod7])
+  subjects: z40.tuple([HashZod11, HashZod11])
 });
-var isCandidatePair = isPayloadOfZodType14(CandidatePairFieldsZod, CandidatePairSchema);
-var asCandidatePair = AsObjectFactory19.create(isCandidatePair);
+var isCandidatePair = isPayloadOfZodType19(CandidatePairFieldsZod, CandidatePairSchema);
+var asCandidatePair = AsObjectFactory24.create(isCandidatePair);
 
 // src/modules/protocol-model/evidence/CandidateSeenPayload.ts
-import { AsObjectFactory as AsObjectFactory20, HashZod as HashZod8 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory25, HashZod as HashZod12 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema20,
-  isPayloadOfZodType as isPayloadOfZodType15,
-  XyoAddressZod as XyoAddressZod8
+  asSchema as asSchema25,
+  isPayloadOfZodType as isPayloadOfZodType20,
+  XyoAddressZod as XyoAddressZod13
 } from "@xyo-network/sdk";
-import { z as z35 } from "zod/mini";
-var CandidateSeenSchema = asSchema20("network.xyo.chain.evidence.candidate", true);
-var CandidateSeenFieldsZod = z35.object({
+import { z as z41 } from "zod/mini";
+var CandidateSeenSchema = asSchema25("network.xyo.chain.evidence.candidate", true);
+var CandidateSeenFieldsZod = z41.object({
   /** Chain the candidate was proposed on */
   chain: ChainIdZod,
   /** Block number the candidate claims */
   height: XL1BlockNumberZod,
   /** Parent hash the candidate builds on — absent only for a genesis candidate */
-  previous: z35.optional(HashZod8),
+  previous: z41.optional(HashZod12),
   /** Address that signed the candidate */
-  producer: XyoAddressZod8,
+  producer: XyoAddressZod13,
   /** Recomputed data hash of the candidate's bound witness */
-  subject: HashZod8
+  subject: HashZod12
 });
-var isCandidateSeen = isPayloadOfZodType15(CandidateSeenFieldsZod, CandidateSeenSchema);
-var asCandidateSeen = AsObjectFactory20.create(isCandidateSeen);
+var isCandidateSeen = isPayloadOfZodType20(CandidateSeenFieldsZod, CandidateSeenSchema);
+var asCandidateSeen = AsObjectFactory25.create(isCandidateSeen);
 
 // src/modules/protocol-model/evidence/EvidenceDisposition.ts
-import { z as z36 } from "zod/mini";
+import { z as z42 } from "zod/mini";
 var EvidenceDispositions = [
   "expired",
   "finalized",
@@ -1103,55 +1249,55 @@ var EvidenceDispositions = [
   "malformed",
   "superseded"
 ];
-var EvidenceDispositionZod = z36.literal(EvidenceDispositions);
+var EvidenceDispositionZod = z42.literal(EvidenceDispositions);
 
 // src/modules/protocol-model/evidence/EvidenceNotePayload.ts
-import { AsObjectFactory as AsObjectFactory21, HashZod as HashZod9 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory26, HashZod as HashZod13 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema21,
-  isPayloadOfZodType as isPayloadOfZodType16,
-  XyoAddressZod as XyoAddressZod9
+  asSchema as asSchema26,
+  isPayloadOfZodType as isPayloadOfZodType21,
+  XyoAddressZod as XyoAddressZod14
 } from "@xyo-network/sdk";
-import { z as z37 } from "zod/mini";
-var EvidenceNoteSchema = asSchema21("network.xyo.chain.evidence.note", true);
-var EvidenceNoteFieldsZod = z37.object({
+import { z as z43 } from "zod/mini";
+var EvidenceNoteSchema = asSchema26("network.xyo.chain.evidence.note", true);
+var EvidenceNoteFieldsZod = z43.object({
   /** Hash of the stored bundle payload this note describes */
-  bundle: HashZod9,
+  bundle: HashZod13,
   /** Why the candidate left the pending pool */
   disposition: EvidenceDispositionZod,
   /** Block number of the archived candidate — absent when the bundle was malformed */
-  height: z37.optional(XL1BlockNumberZod),
+  height: z43.optional(XL1BlockNumberZod),
   /** Finalized head height when the entry was archived — the retention clock for entries with no height */
   observed: XL1BlockNumberZod,
   /** Producer of the archived candidate — absent when the bundle was malformed */
-  producer: z37.optional(XyoAddressZod9),
+  producer: z43.optional(XyoAddressZod14),
   /** Recomputed data hash of the archived block's bound witness — the artifact identity evidence references use */
-  subject: HashZod9
+  subject: HashZod13
 });
-var isEvidenceNote = isPayloadOfZodType16(EvidenceNoteFieldsZod, EvidenceNoteSchema);
-var asEvidenceNote = AsObjectFactory21.create(isEvidenceNote);
+var isEvidenceNote = isPayloadOfZodType21(EvidenceNoteFieldsZod, EvidenceNoteSchema);
+var asEvidenceNote = AsObjectFactory26.create(isEvidenceNote);
 
 // src/modules/protocol-model/fields/BlockNumber.ts
-import { AsObjectFactory as AsObjectFactory22 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory27 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema22,
+  asSchema as asSchema27,
   isPayloadOfSchemaType as isPayloadOfSchemaType6,
   isPayloadOfSchemaTypeWithSources
 } from "@xyo-network/sdk";
-var BlockNumberSchema = asSchema22("network.xyo.chain.block.number", true);
+var BlockNumberSchema = asSchema27("network.xyo.chain.block.number", true);
 var isBlockNumberPayload = isPayloadOfSchemaType6(BlockNumberSchema);
-var asBlockNumberPayload = AsObjectFactory22.create(isBlockNumberPayload);
+var asBlockNumberPayload = AsObjectFactory27.create(isBlockNumberPayload);
 var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
-var asBlockNumberPayloadWithSources = AsObjectFactory22.create(isBlockNumberPayloadWithSources);
+var asBlockNumberPayloadWithSources = AsObjectFactory27.create(isBlockNumberPayloadWithSources);
 
 // src/modules/protocol-model/model/AccountBalance.ts
 import { zodIsFactory as zodIsFactory14 } from "@ariestools/sdk";
 import { WithHashMetaZod as WithHashMetaZod5 } from "@xyo-network/sdk";
-import { z as z43 } from "zod/mini";
+import { z as z49 } from "zod/mini";
 
 // src/modules/protocol-model/model/ChainQualification.ts
-import { HashZod as HashZod10, zodIsFactory as zodIsFactory13 } from "@ariestools/sdk";
-import { z as z42 } from "zod";
+import { HashZod as HashZod14, zodIsFactory as zodIsFactory13 } from "@ariestools/sdk";
+import { z as z48 } from "zod";
 
 // src/modules/protocol-model/model/BlockRange/BlockRange.ts
 import {
@@ -1160,9 +1306,9 @@ import {
   zodAsFactory as zodAsFactory13,
   zodToFactory as zodToFactory13
 } from "@ariestools/sdk";
-import { z as z38 } from "zod";
-var BlockRangeZod = z38.tuple([BlockNumberZod, BlockNumberZod]);
-var BlockRangeishZod = z38.tuple([BlockNumberishZod, BlockNumberishZod]);
+import { z as z44 } from "zod";
+var BlockRangeZod = z44.tuple([BlockNumberZod, BlockNumberZod]);
+var BlockRangeishZod = z44.tuple([BlockNumberishZod, BlockNumberishZod]);
 var asBlockRange = zodAsFactory13(BlockRangeZod, "BlockRange");
 var toBlockRange = zodToFactory13(BlockRangeishZod, "BlockRange");
 var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1179,9 +1325,9 @@ import {
   zodAsFactory as zodAsFactory14,
   zodToFactory as zodToFactory14
 } from "@ariestools/sdk";
-import { z as z39 } from "zod";
-var EthBlockRangeZod = z39.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-var EthBlockRangeishZod = z39.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
+import { z as z45 } from "zod";
+var EthBlockRangeZod = z45.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var EthBlockRangeishZod = z45.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
 var asEthBlockRange = zodAsFactory14(EthBlockRangeZod, "EthBlockRange");
 var toEthBlockRange = zodToFactory14(EthBlockRangeishZod, "EthBlockRange");
 var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1197,8 +1343,8 @@ import {
   zodIsFactory as zodIsFactory12,
   zodToFactory as zodToFactory15
 } from "@ariestools/sdk";
-import { z as z40 } from "zod";
-var RangeZod = z40.tuple([z40.number(), z40.number()]);
+import { z as z46 } from "zod";
+var RangeZod = z46.tuple([z46.number(), z46.number()]);
 var isRange = zodIsFactory12(RangeZod);
 var asRange = zodAsFactory15(RangeZod, "Range");
 var toRange = zodToFactory15(RangeZod, "Range");
@@ -1210,9 +1356,9 @@ import {
   zodAsFactory as zodAsFactory16,
   zodToFactory as zodToFactory16
 } from "@ariestools/sdk";
-import { z as z41 } from "zod";
-var XL1BlockRangeZod = z41.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-var XL1BlockRangeishZod = z41.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
+import { z as z47 } from "zod";
+var XL1BlockRangeZod = z47.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var XL1BlockRangeishZod = z47.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
 var asXL1BlockRange = zodAsFactory16(XL1BlockRangeZod, "XL1BlockRange");
 var toXL1BlockRange = zodToFactory16(XL1BlockRangeishZod, "XL1BlockRange");
 var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1223,29 +1369,29 @@ function fromXL1BlockNumberKey(key, assert) {
 }
 
 // src/modules/protocol-model/model/ChainQualification.ts
-var ChainQualificationZod = z42.object({ head: HashZod10, range: XL1BlockRangeZod });
+var ChainQualificationZod = z48.object({ head: HashZod14, range: XL1BlockRangeZod });
 var isChainQualification = zodIsFactory13(ChainQualificationZod);
-var ChainQualifiedRangeConfigZod = z42.object({ range: XL1BlockRangeZod });
+var ChainQualifiedRangeConfigZod = z48.object({ range: XL1BlockRangeZod });
 var isChainQualifiedRangeConfig = zodIsFactory13(ChainQualifiedRangeConfigZod);
-var ChainQualifiedHeadConfigZod = z42.object({ head: HashZod10 });
+var ChainQualifiedHeadConfigZod = z48.object({ head: HashZod14 });
 var isChainQualifiedHeadConfig = zodIsFactory13(ChainQualifiedHeadConfigZod);
-var ChainQualifiedConfigZod = z42.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z42.object({})]);
+var ChainQualifiedConfigZod = z48.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z48.object({})]);
 var isChainQualifiedConfig = zodIsFactory13(ChainQualifiedConfigZod);
 var ExtendChainQualifiedConfigZod = ((zodType) => {
-  return z42.union([
+  return z48.union([
     ChainQualifiedRangeConfigZod.extend(zodType),
     ChainQualifiedHeadConfigZod.extend(zodType),
     zodType
   ]);
 });
 var ChainQualifiedZod = (zodType) => {
-  return z42.tuple([zodType, ChainQualificationZod]);
+  return z48.tuple([zodType, ChainQualificationZod]);
 };
 
 // src/modules/protocol-model/model/AccountBalance.ts
-var AccountBalanceHistoryItemZod = z43.tuple([
+var AccountBalanceHistoryItemZod = z49.tuple([
   WithHashMetaZod5(BlockBoundWitnessZod),
-  z43.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
+  z49.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
   WithHashMetaZod5(TransferZod)
 ]);
 var AccountBalanceConfigZod = ChainQualifiedConfigZod;
@@ -1264,51 +1410,51 @@ var XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS = "0x319e667cED10452A117472811130444dE
 var XL1_ETH_MAIN_GOVERNANCE_ADDRESS = "0x7595710956d6B14b4f2F51a8dF41379eEeC9074E";
 
 // src/modules/protocol-model/model/ArrayBuffer.ts
-import { z as z44 } from "zod";
+import { z as z50 } from "zod";
 function base64Encode(u8) {
   return u8.toBase64();
 }
 function base64Decode(b64) {
   return Uint8Array.fromBase64(b64);
 }
-var ArrayBufferToJsonZod = z44.instanceof(ArrayBuffer).transform((x) => {
+var ArrayBufferToJsonZod = z50.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
 });
-var JsonToArrayBufferZod = z44.string().transform((x) => {
+var JsonToArrayBufferZod = z50.string().transform((x) => {
   const u8 = base64Decode(x);
   return u8.buffer;
 });
 
 // src/modules/protocol-model/model/BlockRate.ts
 import { zodAsFactory as zodAsFactory17, zodIsFactory as zodIsFactory15 } from "@ariestools/sdk";
-import { z as z45 } from "zod";
-var TimeDurationsZod = z45.object({
-  millis: z45.number().nonnegative(),
-  seconds: z45.number().nonnegative(),
-  minutes: z45.number().nonnegative(),
-  hours: z45.number().nonnegative(),
-  days: z45.number().nonnegative(),
-  weeks: z45.number().nonnegative()
+import { z as z51 } from "zod";
+var TimeDurationsZod = z51.object({
+  millis: z51.number().nonnegative(),
+  seconds: z51.number().nonnegative(),
+  minutes: z51.number().nonnegative(),
+  hours: z51.number().nonnegative(),
+  days: z51.number().nonnegative(),
+  weeks: z51.number().nonnegative()
 });
 var isTimeDurations = zodIsFactory15(TimeDurationsZod);
 var asTimeDurations = zodAsFactory17(TimeDurationsZod, "asTimeDurations");
 var toTimeDurations = zodAsFactory17(TimeDurationsZod, "toTimeDurations");
-var BlockRateZod = z45.object({
+var BlockRateZod = z51.object({
   range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
-  rate: z45.number().nonnegative().describe("rate of blocks per specified time unit"),
+  rate: z51.number().nonnegative().describe("rate of blocks per specified time unit"),
   timeUnit: TimeDurationsZod.keyof().describe("the unit of time for the rate and timePerBlock"),
-  span: z45.int().nonnegative().describe("number of blocks the rate was calculated over"),
-  timeDifference: z45.number().nonnegative().describe("time difference from start and end block"),
-  timePerBlock: z45.number().nonnegative().describe("average time per block for the given range")
+  span: z51.int().nonnegative().describe("number of blocks the rate was calculated over"),
+  timeDifference: z51.number().nonnegative().describe("time difference from start and end block"),
+  timePerBlock: z51.number().nonnegative().describe("average time per block for the given range")
 });
 var isBlockRate = zodIsFactory15(BlockRateZod);
 var asBlockRate = zodAsFactory17(BlockRateZod, "asBlockRate");
 var toBlockRate = zodAsFactory17(BlockRateZod, "toBlockRate");
-var CountZod = z45.int().nonnegative().describe("A non-negative integer count");
-var StepIndexZod = z45.int().min(0).max(StepSizes.length - 1).describe("A non-negative integer step index");
-var timeUnitSchema = z45.number().positive();
-var TimeConfigZod = z45.object({
+var CountZod = z51.int().nonnegative().describe("A non-negative integer count");
+var StepIndexZod = z51.int().min(0).max(StepSizes.length - 1).describe("A non-negative integer step index");
+var timeUnitSchema = z51.number().positive();
+var TimeConfigZod = z51.object({
   minutes: timeUnitSchema.optional(),
   hours: timeUnitSchema.optional(),
   days: timeUnitSchema.optional(),
@@ -1319,30 +1465,30 @@ var TimeConfigZod = z45.object({
 var isTimeConfig = zodIsFactory15(TimeConfigZod);
 var asTimeConfig = zodAsFactory17(TimeConfigZod, "asTimeConfig");
 var toTimeConfig = zodAsFactory17(TimeConfigZod, "toTimeConfig");
-var SingleTimeConfigZod = z45.union([
-  z45.object({ minutes: timeUnitSchema }),
-  z45.object({ hours: timeUnitSchema }),
-  z45.object({ days: timeUnitSchema }),
-  z45.object({ weeks: timeUnitSchema }),
-  z45.object({ months: timeUnitSchema }),
-  z45.object({ years: timeUnitSchema })
+var SingleTimeConfigZod = z51.union([
+  z51.object({ minutes: timeUnitSchema }),
+  z51.object({ hours: timeUnitSchema }),
+  z51.object({ days: timeUnitSchema }),
+  z51.object({ weeks: timeUnitSchema }),
+  z51.object({ months: timeUnitSchema }),
+  z51.object({ years: timeUnitSchema })
 ]).describe("Time configuration with exactly one time unit");
 var isSingleTimeConfig = zodIsFactory15(SingleTimeConfigZod);
 var asSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "asSingleTimeConfig");
 var toSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "toSingleTimeConfig");
 
 // src/modules/protocol-model/model/Context/BaseContext.zod.ts
-import { z as z46 } from "zod";
-var CachesZod = z46.record(
-  z46.string(),
-  z46.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
+import { z as z52 } from "zod";
+var CachesZod = z52.record(
+  z52.string(),
+  z52.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
 );
-var SingletonsZod = z46.record(z46.union([z46.string(), z46.symbol()]), z46.unknown());
-var LoggerZod = z46.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
-var MeterProviderZod = z46.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
-var TracerProviderZod = z46.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
-var TimeBudgetLimitZod = z46.number();
-var BaseContextZod = z46.object({
+var SingletonsZod = z52.record(z52.union([z52.string(), z52.symbol()]), z52.unknown());
+var LoggerZod = z52.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
+var MeterProviderZod = z52.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
+var TracerProviderZod = z52.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
+var TimeBudgetLimitZod = z52.number();
+var BaseContextZod = z52.object({
   caches: CachesZod.optional(),
   logger: LoggerZod.optional(),
   meterProvider: MeterProviderZod.optional(),
@@ -1352,24 +1498,24 @@ var BaseContextZod = z46.object({
 });
 
 // src/modules/protocol-model/model/Context/BlockContext.zod.ts
-import z47 from "zod";
+import z53 from "zod";
 
 // src/modules/protocol-model/model/Context/CachingContext.zod.ts
 var CachingContextZod = BaseContextZod.extend({ caches: CachesZod });
 
 // src/modules/protocol-model/model/Context/BlockContext.zod.ts
 var BlockContextReadZod = CachingContextZod.extend(
-  { chainMap: z47.custom((val) => val != null && typeof val === "object" && "get" in val) }
+  { chainMap: z53.custom((val) => val != null && typeof val === "object" && "get" in val) }
 );
 var BlockContextWriteZod = CachingContextZod.extend(
-  { chainMap: z47.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
+  { chainMap: z53.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
 );
 var BlockContextZod = BlockContextWriteZod;
 
 // src/modules/protocol-model/model/Context/HeadContext.zod.ts
 import { WithHashMetaZod as WithHashMetaZod6 } from "@xyo-network/sdk";
-import z48 from "zod";
-var HeadContextBaseZod = z48.object(
+import z54 from "zod";
+var HeadContextBaseZod = z54.object(
   { head: WithHashMetaZod6(BlockBoundWitnessZod) }
 );
 var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
@@ -1414,45 +1560,45 @@ import {
   WithHashMetaZod as WithHashMetaZod7,
   WithStorageMetaZod as WithStorageMetaZod5
 } from "@xyo-network/sdk";
-import { z as z49 } from "zod/mini";
-var HydratedTransactionZod = z49.tuple([
+import { z as z55 } from "zod/mini";
+var HydratedTransactionZod = z55.tuple([
   TransactionBoundWitnessZod,
-  z49.array(PayloadZodLoose2)
+  z55.array(PayloadZodLoose2)
 ]);
 var isHydratedTransaction = zodIsFactory16(HydratedTransactionZod);
 var asHydratedTransaction = zodAsFactory18(HydratedTransactionZod, "asHydratedTransaction");
 var toHydratedTransaction = zodToFactory17(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z49.tuple([
+var HydratedTransactionWithHashMetaZod = z55.tuple([
   WithHashMetaZod7(TransactionBoundWitnessZod),
-  z49.array(z49.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z55.array(z55.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isHydratedTransactionWithHashMeta = zodIsFactory16(HydratedTransactionWithHashMetaZod);
 var asHydratedTransactionWithHashMeta = zodAsFactory18(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
 var toHydratedTransactionWithHashMeta = zodToFactory17(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z49.tuple([
+var HydratedTransactionWithStorageMetaZod = z55.tuple([
   WithStorageMetaZod5(TransactionBoundWitnessZod),
-  z49.array(z49.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z55.array(z55.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isHydratedTransactionWithStorageMeta = zodIsFactory16(HydratedTransactionWithStorageMetaZod);
 var asHydratedTransactionWithStorageMeta = zodAsFactory18(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
 var toHydratedTransactionWithStorageMeta = zodToFactory17(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z49.tuple([
+var UnsignedHydratedTransactionZod = z55.tuple([
   UnsignedTransactionBoundWitnessZod,
-  z49.array(PayloadZodLoose2)
+  z55.array(PayloadZodLoose2)
 ]);
 var isUnsignedHydratedTransaction = zodIsFactory16(UnsignedHydratedTransactionZod);
 var asUnsignedHydratedTransaction = zodAsFactory18(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
 var toUnsignedHydratedTransaction = zodToFactory17(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z49.tuple([
+var UnsignedHydratedTransactionWithHashMetaZod = z55.tuple([
   WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
-  z49.array(z49.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z55.array(z55.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory16(UnsignedHydratedTransactionWithHashMetaZod);
 var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory18(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
 var toUnsignedHydratedTransactionWithHashMeta = zodToFactory17(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z49.tuple([
+var UnsignedHydratedTransactionWithStorageMetaZod = z55.tuple([
   WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
-  z49.array(z49.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z55.array(z55.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory16(UnsignedHydratedTransactionWithStorageMetaZod);
 var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory18(
@@ -1463,23 +1609,23 @@ var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory17(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z49.tuple([
+var SignedHydratedTransactionZod = z55.tuple([
   SignedTransactionBoundWitnessZod,
-  z49.array(PayloadZodLoose2)
+  z55.array(PayloadZodLoose2)
 ]);
 var isSignedHydratedTransaction = zodIsFactory16(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory18(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var toSignedHydratedTransaction = zodToFactory17(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z49.tuple([
+var SignedHydratedTransactionWithHashMetaZod = z55.tuple([
   WithHashMetaZod7(SignedTransactionBoundWitnessZod),
-  z49.array(z49.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z55.array(z55.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isSignedHydratedTransactionWithHashMeta = zodIsFactory16(SignedHydratedTransactionWithHashMetaZod);
 var asSignedHydratedTransactionWithHashMeta = zodAsFactory18(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
 var toSignedHydratedTransactionWithHashMeta = zodToFactory17(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z49.tuple([
+var SignedHydratedTransactionWithStorageMetaZod = z55.tuple([
   WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
-  z49.array(z49.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z55.array(z55.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isSignedHydratedTransactionWithStorageMeta = zodIsFactory16(SignedHydratedTransactionWithStorageMetaZod);
 var asSignedHydratedTransactionWithStorageMeta = zodAsFactory18(
@@ -1495,22 +1641,22 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory17(
 var ELEVATE_OPCODE = "elevate";
 
 // src/modules/protocol-model/model/Permission.ts
-import { z as z50 } from "zod";
-var CaveatTypesZod = z50.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z50.object({
+import { z as z56 } from "zod";
+var CaveatTypesZod = z56.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z56.object({
   type: CaveatTypesZod,
-  value: z50.json()
+  value: z56.json()
 });
-var PermissionZod = z50.object({
-  parentCapability: z50.string(),
+var PermissionZod = z56.object({
+  parentCapability: z56.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z50.string()
+  invoker: z56.string()
 });
-var InvokerPermissionZod = PermissionZod.safeExtend({ date: z50.number().optional() });
-var PermissionRequestZod = z50.record(z50.string(), z50.record(z50.string(), z50.any()));
-var RequestedPermissionZod = z50.object({
-  parentCapability: z50.string(),
-  date: z50.number().optional()
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z56.number().optional() });
+var PermissionRequestZod = z56.record(z56.string(), z56.record(z56.string(), z56.any()));
+var RequestedPermissionZod = z56.object({
+  parentCapability: z56.string(),
+  date: z56.number().optional()
 });
 
 // src/modules/protocol-model/model/rewards.ts
@@ -1524,54 +1670,87 @@ var XL1_REWARDS_MIN_BLOCK_REWARD = asAttoXL1(toFixedPoint(10n, XL1_REWARDS_PLACE
 var XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20000000000n, XL1_REWARDS_PLACES));
 
 // src/modules/protocol-model/model/RewardsRangeOptions.ts
-import { XyoAddressZod as XyoAddressZod10 } from "@xyo-network/sdk";
-import { z as z51 } from "zod";
-var RewardsRangeOptionsZod = z51.object({
-  positions: z51.array(z51.number()).optional(),
+import { XyoAddressZod as XyoAddressZod15 } from "@xyo-network/sdk";
+import { z as z57 } from "zod";
+var RewardsRangeOptionsZod = z57.object({
+  positions: z57.array(z57.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z51.array(StepIdentityZod).optional(),
-  stakers: z51.array(XyoAddressZod10).optional()
+  steps: z57.array(StepIdentityZod).optional(),
+  stakers: z57.array(XyoAddressZod15).optional()
 });
 
+// src/modules/protocol-model/model/RuleActivation.ts
+var RuleIds = [
+  "intent-binding",
+  "anchor-rules",
+  "single-signer",
+  "supersedes-field",
+  "slash-payloads",
+  "eligibility-admission",
+  "attestation-admission",
+  "certificate-execution",
+  ...OffenseCodes.map((code) => `${code}.reportable`),
+  ...OffenseCodes.map((code) => `${code}.adjudicable`)
+];
+function reportableRuleId(offense) {
+  return `${offense}.reportable`;
+}
+function adjudicableRuleId(offense) {
+  return `${offense}.adjudicable`;
+}
+function ruleActivationStateAt(params, ruleId, height) {
+  const activation = params.activations[ruleId];
+  if (activation === void 0 || height < activation) return "inactive";
+  const deactivation = params.deactivations?.[ruleId];
+  if (deactivation !== void 0 && height >= deactivation) return "inactive";
+  return height < activation + (params.graceBandXl1Blocks ?? 0) ? "grace" : "active";
+}
+function isRuleActiveAt(params, ruleId, height) {
+  return ruleActivationStateAt(params, ruleId, height) === "active";
+}
+function isRuleObservedAt(params, ruleId, height) {
+  return ruleActivationStateAt(params, ruleId, height) !== "inactive";
+}
+
 // src/modules/protocol-model/model/Sequence.ts
 import { HexRegExMinMax, toHex } from "@ariestools/sdk";
 import { SequenceConstants } from "@xyo-network/sdk";
-import { z as z52 } from "zod";
+import { z as z58 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z52.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z52.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z58.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z58.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z52.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z52.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z52.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z52.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+var QualifiedSequenceToStringZod = z58.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z58.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z58.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z58.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
 
 // src/modules/protocol-model/model/Stake.ts
 import { HexZod as HexZod7 } from "@ariestools/sdk";
-import { XyoAddressZod as XyoAddressZod11 } from "@xyo-network/sdk";
-import { z as z53 } from "zod";
-var StakeZod = z53.object({
+import { XyoAddressZod as XyoAddressZod16 } from "@xyo-network/sdk";
+import { z as z59 } from "zod";
+var StakeZod = z59.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z53.number(),
+  addBlock: z59.number(),
   // the unique id for the stake item
-  id: z53.number(),
+  id: z59.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z53.number(),
+  removeBlock: z59.number(),
   // the address that is being staked
-  staked: XyoAddressZod11,
+  staked: XyoAddressZod16,
   // the address that owns the stake
-  staker: XyoAddressZod11,
+  staker: XyoAddressZod16,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z53.number()
+  withdrawBlock: z59.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
   amount: BigIntToJsonZod2.parse(val.amount),
   id: val.id,
   removeBlock: val.removeBlock,
-  staked: XyoAddressZod11.parse(val.staked),
-  staker: XyoAddressZod11.parse(val.staker),
+  staked: XyoAddressZod16.parse(val.staked),
+  staker: XyoAddressZod16.parse(val.staker),
   withdrawBlock: val.withdrawBlock
 }));
 var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
@@ -1590,78 +1769,78 @@ import {
   zodIsFactory as zodIsFactory17,
   zodToFactory as zodToFactory18
 } from "@ariestools/sdk";
-import { z as z54 } from "zod";
-var SyncStepSummaryMetadataZod = z54.object({
+import { z as z60 } from "zod";
+var SyncStepSummaryMetadataZod = z60.object({
   block: XL1BlockNumberZod,
-  blockCount: z54.int().nonnegative(),
-  bytes: z54.int().nonnegative(),
-  createdAt: z54.string(),
+  blockCount: z60.int().nonnegative(),
+  bytes: z60.int().nonnegative(),
+  createdAt: z60.string(),
   endBlock: XL1BlockNumberZod,
-  relativePath: z54.string(),
+  relativePath: z60.string(),
   startBlock: XL1BlockNumberZod,
-  step: z54.int().nonnegative(),
+  step: z60.int().nonnegative(),
   stepSize: XL1BlockNumberZod,
-  updatedAt: z54.string()
+  updatedAt: z60.string()
 });
 var isSyncStepSummaryMetadata = zodIsFactory17(SyncStepSummaryMetadataZod);
 var asSyncStepSummaryMetadata = zodAsFactory19(SyncStepSummaryMetadataZod, "asSyncStepSummaryMetadata");
 var toSyncStepSummaryMetadata = zodToFactory18(SyncStepSummaryMetadataZod, "toSyncStepSummaryMetadata");
-var SyncStepSummaryStatusZod = z54.object({
-  currentBlock: z54.optional(XL1BlockNumberZod),
-  isIndexing: z54.boolean(),
-  nextBoundaries: z54.record(z54.string(), XL1BlockNumberZod),
-  summaries: z54.array(SyncStepSummaryMetadataZod),
-  summaryCount: z54.int().nonnegative()
+var SyncStepSummaryStatusZod = z60.object({
+  currentBlock: z60.optional(XL1BlockNumberZod),
+  isIndexing: z60.boolean(),
+  nextBoundaries: z60.record(z60.string(), XL1BlockNumberZod),
+  summaries: z60.array(SyncStepSummaryMetadataZod),
+  summaryCount: z60.int().nonnegative()
 });
 var isSyncStepSummaryStatus = zodIsFactory17(SyncStepSummaryStatusZod);
 var asSyncStepSummaryStatus = zodAsFactory19(SyncStepSummaryStatusZod, "asSyncStepSummaryStatus");
 var toSyncStepSummaryStatus = zodToFactory18(SyncStepSummaryStatusZod, "toSyncStepSummaryStatus");
-var SyncStepSummaryZod = z54.array(SignedHydratedBlockWithHashMetaZod);
+var SyncStepSummaryZod = z60.array(SignedHydratedBlockWithHashMetaZod);
 var isSyncStepSummary = zodIsFactory17(SyncStepSummaryZod);
 var asSyncStepSummary = zodAsFactory19(SyncStepSummaryZod, "asSyncStepSummary");
 var toSyncStepSummary = zodToFactory18(SyncStepSummaryZod, "toSyncStepSummary");
 
 // src/modules/protocol-model/model/TimeDomain.ts
-import { z as z55 } from "zod";
-var TimeDomainZod = z55.union([
-  z55.literal("xl1"),
-  z55.literal("epoch"),
-  z55.literal("ethereum")
+import { z as z61 } from "zod";
+var TimeDomainZod = z61.union([
+  z61.literal("xl1"),
+  z61.literal("epoch"),
+  z61.literal("ethereum")
 ]);
 
 // src/modules/protocol-model/model/TransactionInclusion.ts
 import {
-  HashZod as HashZod11,
+  HashZod as HashZod15,
   zodAsFactory as zodAsFactory20,
   zodIsFactory as zodIsFactory18,
   zodToFactory as zodToFactory19
 } from "@ariestools/sdk";
-import { z as z56 } from "zod";
-var TransactionInclusionZod = z56.object({
+import { z as z62 } from "zod";
+var TransactionInclusionZod = z62.object({
   /** Hash of the finalized block containing the transaction. */
-  blockHash: HashZod11,
+  blockHash: HashZod15,
   /** Number of the finalized block containing the transaction. */
   blockNumber: XL1BlockNumberZod,
   /** Hash of the included transaction. */
-  transactionHash: HashZod11,
+  transactionHash: HashZod15,
   /** Zero-based transaction position within the block. */
-  transactionIndex: z56.int().nonnegative()
+  transactionIndex: z62.int().nonnegative()
 });
 var isTransactionInclusion = zodIsFactory18(TransactionInclusionZod);
 var asTransactionInclusion = zodAsFactory20(TransactionInclusionZod, "asTransactionInclusion");
 var toTransactionInclusion = zodToFactory19(TransactionInclusionZod, "toTransactionInclusion");
 
 // src/modules/protocol-model/model/TransferPair.ts
-import { XyoAddressZod as XyoAddressZod12 } from "@xyo-network/sdk";
-import { z as z57 } from "zod";
-var TransferPairZod = z57.tuple([
-  XyoAddressZod12,
-  XyoAddressZod12
+import { XyoAddressZod as XyoAddressZod17 } from "@xyo-network/sdk";
+import { z as z63 } from "zod";
+var TransferPairZod = z63.tuple([
+  XyoAddressZod17,
+  XyoAddressZod17
 ]);
 
 // src/modules/protocol-model/model/version.ts
 var XL1_PROTOCOL_VERSION_MAJOR = 1;
-var XL1_PROTOCOL_VERSION_MINOR = 2;
+var XL1_PROTOCOL_VERSION_MINOR = 3;
 var XL1_PROTOCOL_VERSION_PATCH = 0;
 var XL1_PROTOCOL_VERSION_STRING = `${XL1_PROTOCOL_VERSION_MAJOR}.${XL1_PROTOCOL_VERSION_MINOR}.${XL1_PROTOCOL_VERSION_PATCH}`;
 var XL1_PROTOCOL_VERSION = XL1_PROTOCOL_VERSION_MAJOR * 1e6 + XL1_PROTOCOL_VERSION_MINOR * 1e3 + XL1_PROTOCOL_VERSION_PATCH;
@@ -1675,57 +1854,57 @@ var asProviderMoniker = (value) => {
 var DefaultProviderMoniker = "Provider";
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory23 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory28 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema23,
+  asSchema as asSchema28,
   isPayloadOfSchemaType as isPayloadOfSchemaType7,
   PayloadZodOfSchema as PayloadZodOfSchema3
 } from "@xyo-network/sdk";
-import { z as z59 } from "zod/mini";
+import { z as z65 } from "zod/mini";
 
 // src/modules/protocol-model/rejection/RejectionError.ts
-import { HashZod as HashZod12 } from "@ariestools/sdk";
-import { z as z58 } from "zod";
-var RejectionErrorZod = z58.object({
-  hash: HashZod12,
-  message: z58.string().optional(),
-  name: z58.string()
+import { HashZod as HashZod16 } from "@ariestools/sdk";
+import { z as z64 } from "zod";
+var RejectionErrorZod = z64.object({
+  hash: HashZod16,
+  message: z64.string().optional(),
+  name: z64.string()
 }).loose();
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-var BlockRejectionSchema = asSchema23("network.xyo.block.rejection", true);
-var BlockRejectionFieldsZod = z59.object({
+var BlockRejectionSchema = asSchema28("network.xyo.block.rejection", true);
+var BlockRejectionFieldsZod = z65.object({
   block: HydratedBlockZod,
-  errors: z59.array(RejectionErrorZod),
-  rejector: z59.string()
+  errors: z65.array(RejectionErrorZod),
+  rejector: z65.string()
 });
-var BlockRejectionZod = z59.extend(
+var BlockRejectionZod = z65.extend(
   PayloadZodOfSchema3(BlockRejectionSchema),
   BlockRejectionFieldsZod.shape
 );
 var isBlockRejection = isPayloadOfSchemaType7(BlockRejectionSchema);
-var asBlockRejection = AsObjectFactory23.create(isBlockRejection);
+var asBlockRejection = AsObjectFactory28.create(isBlockRejection);
 
 // src/modules/protocol-model/rejection/TransactionRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory24 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory29 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema24,
+  asSchema as asSchema29,
   isPayloadOfSchemaType as isPayloadOfSchemaType8,
   PayloadZodOfSchema as PayloadZodOfSchema4
 } from "@xyo-network/sdk";
-import { z as z60 } from "zod/mini";
-var TransactionRejectionSchema = asSchema24("network.xyo.transaction.rejection", true);
-var TransactionRejectionFieldsZod = z60.object({
-  errors: z60.array(RejectionErrorZod),
-  rejector: z60.string(),
+import { z as z66 } from "zod/mini";
+var TransactionRejectionSchema = asSchema29("network.xyo.transaction.rejection", true);
+var TransactionRejectionFieldsZod = z66.object({
+  errors: z66.array(RejectionErrorZod),
+  rejector: z66.string(),
   transaction: HydratedTransactionZod
 });
-var TransactionRejectionZod = z60.extend(
+var TransactionRejectionZod = z66.extend(
   PayloadZodOfSchema4(TransactionRejectionSchema),
   TransactionRejectionFieldsZod.shape
 );
 var isTransactionRejection = isPayloadOfSchemaType8(TransactionRejectionSchema);
-var asTransactionRejection = AsObjectFactory24.create(isTransactionRejection);
+var asTransactionRejection = AsObjectFactory29.create(isTransactionRejection);
 export {
   AccountBalanceConfigZod,
   AccountBalanceHistoryItemZod,
@@ -1837,6 +2016,8 @@ export {
   NanoXL1,
   NanoXL1MaxValue,
   NumberishZod,
+  OffenseCodeZod,
+  OffenseCodes,
   OrdinalTransferFieldsZod,
   OrdinalTransferSchema,
   PartySecretRevealFieldsZod,
@@ -1851,6 +2032,7 @@ export {
   RejectionErrorZod,
   RequestedPermissionZod,
   RewardsRangeOptionsZod,
+  RuleIds,
   SequenceFromStringZod,
   SequenceToStringZod,
   SignedBlockBoundWitnessWithHashMetaZod,
@@ -1872,6 +2054,18 @@ export {
   SignedTransactionBoundWitnessZod,
   SingleTimeConfigZod,
   SingletonsZod,
+  SlashAdjudicationFieldsZod,
+  SlashAdjudicationSchema,
+  SlashChallengeFieldsZod,
+  SlashChallengeSchema,
+  SlashCommitFieldsZod,
+  SlashCommitSchema,
+  SlashEvidenceFieldsZod,
+  SlashEvidenceSchema,
+  SlashOutcomeZod,
+  SlashOutcomes,
+  SlashRequestFieldsZod,
+  SlashRequestSchema,
   StakeToJsonZod,
   StakeZod,
   StepCompleteSchema,
@@ -1957,6 +2151,7 @@ export {
   XYO_NETWORK_STAKING_ADDRESS,
   XYO_STEP_REWARD_ADDRESS,
   XYO_ZERO_ADDRESS,
+  adjudicableRuleId,
   asAttoXL1,
   asBlockBoundWitness,
   asBlockBoundWitnessWithHashMeta,
@@ -2012,6 +2207,11 @@ export {
   asSignedTransactionBoundWitnessWithHashMeta,
   asSignedTransactionBoundWitnessWithStorageMeta,
   asSingleTimeConfig,
+  asSlashAdjudication,
+  asSlashChallenge,
+  asSlashCommit,
+  asSlashEvidence,
+  asSlashRequest,
   asStepComplete,
   asStepIdentity,
   asStepIdentityPayload,
@@ -2096,6 +2296,8 @@ export {
   isPartySecretReveal,
   isPicoXL1,
   isRange,
+  isRuleActiveAt,
+  isRuleObservedAt,
   isSafeEpoch,
   isSignedBlockBoundWitness,
   isSignedBlockBoundWitnessWithHashMeta,
@@ -2111,6 +2313,11 @@ export {
   isSignedTransactionBoundWitnessWithHashMeta,
   isSignedTransactionBoundWitnessWithStorageMeta,
   isSingleTimeConfig,
+  isSlashAdjudication,
+  isSlashChallenge,
+  isSlashCommit,
+  isSlashEvidence,
+  isSlashRequest,
   isStepComplete,
   isStepIdentityPayload,
   isStepWitness,
@@ -2142,6 +2349,8 @@ export {
   isValidStep,
   isXL1,
   minTransactionFees,
+  reportableRuleId,
+  ruleActivationStateAt,
   stepSize,
   toAttoXL1,
   toBlockBoundWitness,