@xyo-network/xl1-protocol 5.3.6 → 5.3.8

package/dist/neutral/protocol-model.mjs

@@ -1,12 +1,12 @@
 // src/modules/protocol-model/block/AllowedBlockPayload.ts
-import { zodIsFactory as zodIsFactory5 } from "@ariestools/sdk";
+import { zodIsFactory as zodIsFactory6 } from "@ariestools/sdk";
 import {
   BoundWitnessSchema,
   isHashMeta,
   isSchemaPayload,
   SchemaSchema
 } from "@xyo-network/sdk";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 
 // src/modules/protocol-model/payload/application/Exchange/ExchangeOutcome.ts
 import { AsObjectFactory, HashZod } from "@ariestools/sdk";
@@ -609,6 +609,38 @@ var asNonNegativeInteger = (num) => {
   return Number.isSafeInteger(num) && num >= 0 ? num : void 0;
 };
 
+// src/modules/protocol-model/payload/elevatable/Claim.ts
+import {
+  AsObjectFactory as AsObjectFactory13,
+  HashZod as HashZod4,
+  zodIsFactory as zodIsFactory4
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema13,
+  isPayloadOfSchemaType as isPayloadOfSchemaType2,
+  PayloadZodOfSchema,
+  XyoAddressZod as XyoAddressZod5
+} from "@xyo-network/sdk";
+import { z as z23 } from "zod/mini";
+var ClaimSchema = asSchema13("network.xyo.statement.claim", true);
+var MAX_CLAIM_HASHES = 256;
+var ClaimFieldsZod = z23.object({
+  hashes: z23.array(HashZod4).check(
+    z23.minLength(1),
+    z23.maxLength(MAX_CLAIM_HASHES),
+    z23.refine(
+      (hashes) => new Set(hashes).size === hashes.length,
+      { error: "duplicate hashes" }
+    )
+  ),
+  source: XyoAddressZod5
+});
+var ClaimZod = z23.extend(PayloadZodOfSchema(ClaimSchema), ClaimFieldsZod.shape);
+var isClaim = isPayloadOfSchemaType2(ClaimSchema);
+var isClaimPayload = zodIsFactory4(ClaimZod);
+var asClaim = AsObjectFactory13.create(isClaim);
+var asClaimPayload = AsObjectFactory13.create(isClaimPayload);
+
 // src/modules/protocol-model/payload/elevatable/Executable.ts
 import { isAnyPayload } from "@xyo-network/sdk";
 var hasFrom = (value) => {
@@ -622,158 +654,158 @@ var asExecutable = (value) => {
 };
 
 // src/modules/protocol-model/payload/elevatable/Hash.ts
-import { AsObjectFactory as AsObjectFactory13 } from "@ariestools/sdk";
-import { asSchema as asSchema13, isPayloadOfSchemaType as isPayloadOfSchemaType2 } from "@xyo-network/sdk";
-var HashSchema = asSchema13("network.xyo.hash", true);
-var isHashPayload = isPayloadOfSchemaType2(HashSchema);
-var asHashPayload = AsObjectFactory13.create(isHashPayload);
-var asHashPayloadWithStorageMeta = AsObjectFactory13.create(isHashPayload);
-
-// src/modules/protocol-model/payload/elevatable/StepComplete.ts
 import { AsObjectFactory as AsObjectFactory14 } from "@ariestools/sdk";
 import { asSchema as asSchema14, isPayloadOfSchemaType as isPayloadOfSchemaType3 } from "@xyo-network/sdk";
-var StepCompleteSchema = asSchema14("network.xyo.chain.step.complete", true);
-var isStepComplete = isPayloadOfSchemaType3(StepCompleteSchema);
-var asStepComplete = AsObjectFactory14.create(isStepComplete);
+var HashSchema = asSchema14("network.xyo.hash", true);
+var isHashPayload = isPayloadOfSchemaType3(HashSchema);
+var asHashPayload = AsObjectFactory14.create(isHashPayload);
+var asHashPayloadWithStorageMeta = AsObjectFactory14.create(isHashPayload);
+
+// src/modules/protocol-model/payload/elevatable/StepComplete.ts
+import { AsObjectFactory as AsObjectFactory15 } from "@ariestools/sdk";
+import { asSchema as asSchema15, isPayloadOfSchemaType as isPayloadOfSchemaType4 } from "@xyo-network/sdk";
+var StepCompleteSchema = asSchema15("network.xyo.chain.step.complete", true);
+var isStepComplete = isPayloadOfSchemaType4(StepCompleteSchema);
+var asStepComplete = AsObjectFactory15.create(isStepComplete);
 
 // src/modules/protocol-model/payload/elevatable/Time.ts
-import { AsObjectFactory as AsObjectFactory15, HashZod as HashZod4 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory16, HashZod as HashZod5 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema15,
-  isPayloadOfSchemaType as isPayloadOfSchemaType4,
-  PayloadZodOfSchema
+  asSchema as asSchema16,
+  isPayloadOfSchemaType as isPayloadOfSchemaType5,
+  PayloadZodOfSchema as PayloadZodOfSchema2
 } from "@xyo-network/sdk";
-import { z as z23 } from "zod/mini";
-var TimeSchema = asSchema15("network.xyo.time", true);
-var XL1TimeFieldsZod = z23.object({
+import { z as z24 } from "zod/mini";
+var TimeSchema = asSchema16("network.xyo.time", true);
+var XL1TimeFieldsZod = z24.object({
   // block number
-  xl1: z23.optional(z23.number()),
+  xl1: z24.optional(z24.number()),
   // block hash
-  xl1Hash: z23.optional(HashZod4)
+  xl1Hash: z24.optional(HashZod5)
 });
-var EthereumTimeFieldsZod = z23.object({
+var EthereumTimeFieldsZod = z24.object({
   // block number
-  ethereum: z23.optional(z23.number()),
+  ethereum: z24.optional(z24.number()),
   // block hash
-  ethereumHash: z23.optional(HashZod4)
+  ethereumHash: z24.optional(HashZod5)
 });
-var EpochTimeFieldsZod = z23.object({
+var EpochTimeFieldsZod = z24.object({
   // in milliseconds
-  epoch: z23.number()
+  epoch: z24.number()
 });
-var TimeFieldsZod = z23.extend(
-  z23.extend(z23.extend(XL1TimeFieldsZod, XL1TimeFieldsZod.shape), EthereumTimeFieldsZod.shape),
+var TimeFieldsZod = z24.extend(
+  z24.extend(z24.extend(XL1TimeFieldsZod, XL1TimeFieldsZod.shape), EthereumTimeFieldsZod.shape),
   EpochTimeFieldsZod.shape
 );
-var TimePayloadZod = z23.extend(PayloadZodOfSchema(TimeSchema), TimeFieldsZod.shape);
+var TimePayloadZod = z24.extend(PayloadZodOfSchema2(TimeSchema), TimeFieldsZod.shape);
 var MAX_SAFE_EPOCH = 9999999999999;
 var isSafeEpoch = (value) => {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= MAX_SAFE_EPOCH;
 };
 var isTimePayload = (value) => {
-  return isPayloadOfSchemaType4(TimeSchema)(value) && isSafeEpoch(value.epoch);
+  return isPayloadOfSchemaType5(TimeSchema)(value) && isSafeEpoch(value.epoch);
 };
-var asTimePayload = AsObjectFactory15.create(isTimePayload);
-var asTimePayloadWithStorageMeta = AsObjectFactory15.create(isTimePayload);
+var asTimePayload = AsObjectFactory16.create(isTimePayload);
+var asTimePayloadWithStorageMeta = AsObjectFactory16.create(isTimePayload);
 
 // src/modules/protocol-model/payload/slash/SlashAdjudicationPayload.ts
-import { AsObjectFactory as AsObjectFactory16, HashZod as HashZod5 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory17, HashZod as HashZod6 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema16,
+  asSchema as asSchema17,
   isPayloadOfZodType as isPayloadOfZodType12,
-  XyoAddressZod as XyoAddressZod5
+  XyoAddressZod as XyoAddressZod6
 } from "@xyo-network/sdk";
-import { z as z24 } from "zod/mini";
+import { z as z25 } 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({
+var SlashOutcomeZod = z25.literal(SlashOutcomes);
+var SlashAdjudicationSchema = asSchema17("network.xyo.chain.slash.adjudication", true);
+var SlashAdjudicationFieldsZod = z25.object({
   /** Address credited with the report, required once bounties are paid. */
-  claimant: z24.optional(XyoAddressZod5),
+  claimant: z25.optional(XyoAddressZod6),
   /** Hash of the commitment that won the claim. */
-  claimantCommit: z24.optional(HashZod5),
+  claimantCommit: z25.optional(HashZod6),
   /** Address issuing the adjudication. */
-  from: XyoAddressZod5,
+  from: XyoAddressZod6,
   /** How the request was resolved. */
   outcome: SlashOutcomeZod,
   /** Why, for any outcome other than confirmed. */
-  reason: z24.optional(z24.string()),
+  reason: z25.optional(z25.string()),
   /** Hash of the request being adjudicated. */
-  request: HashZod5
+  request: HashZod6
 });
 var isSlashAdjudication = isPayloadOfZodType12(
   SlashAdjudicationFieldsZod,
   SlashAdjudicationSchema
 );
-var asSlashAdjudication = AsObjectFactory16.create(isSlashAdjudication);
+var asSlashAdjudication = AsObjectFactory17.create(isSlashAdjudication);
 
 // src/modules/protocol-model/payload/slash/SlashChallengePayload.ts
-import { AsObjectFactory as AsObjectFactory17, HashZod as HashZod6 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory18, HashZod as HashZod7 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema17,
+  asSchema as asSchema18,
   isPayloadOfZodType as isPayloadOfZodType13,
-  XyoAddressZod as XyoAddressZod6
+  XyoAddressZod as XyoAddressZod7
 } from "@xyo-network/sdk";
-import { z as z25 } from "zod/mini";
-var SlashChallengeSchema = asSchema17("network.xyo.chain.slash.challenge", true);
-var SlashChallengeFieldsZod = z25.object({
+import { z as z26 } from "zod/mini";
+var SlashChallengeSchema = asSchema18("network.xyo.chain.slash.challenge", true);
+var SlashChallengeFieldsZod = z26.object({
   /** Hashes of the counter-artifacts, carried in accompanying evidence payloads. */
-  evidence: z25.array(HashZod6),
+  evidence: z26.array(HashZod7),
   /** Address filing the challenge. */
-  from: XyoAddressZod6,
+  from: XyoAddressZod7,
   /** Hash of the request being challenged. */
-  request: HashZod6
+  request: HashZod7
 });
 var isSlashChallenge = isPayloadOfZodType13(SlashChallengeFieldsZod, SlashChallengeSchema);
-var asSlashChallenge = AsObjectFactory17.create(isSlashChallenge);
+var asSlashChallenge = AsObjectFactory18.create(isSlashChallenge);
 
 // src/modules/protocol-model/payload/slash/SlashCommitPayload.ts
-import { AsObjectFactory as AsObjectFactory18, HashZod as HashZod7 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory19, HashZod as HashZod8 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema18,
+  asSchema as asSchema19,
   isPayloadOfZodType as isPayloadOfZodType14,
-  XyoAddressZod as XyoAddressZod7
+  XyoAddressZod as XyoAddressZod8
 } from "@xyo-network/sdk";
-import { z as z26 } from "zod/mini";
-var SlashCommitSchema = asSchema18("network.xyo.chain.slash.commit", true);
-var SlashCommitFieldsZod = z26.object({
+import { z as z27 } from "zod/mini";
+var SlashCommitSchema = asSchema19("network.xyo.chain.slash.commit", true);
+var SlashCommitFieldsZod = z27.object({
   /** Hash of the report this commitment reserves. */
-  commitment: HashZod7,
+  commitment: HashZod8,
   /** Address that will file the report. */
-  from: XyoAddressZod7
+  from: XyoAddressZod8
 });
 var isSlashCommit = isPayloadOfZodType14(SlashCommitFieldsZod, SlashCommitSchema);
-var asSlashCommit = AsObjectFactory18.create(isSlashCommit);
+var asSlashCommit = AsObjectFactory19.create(isSlashCommit);
 
 // src/modules/protocol-model/payload/slash/SlashEvidencePayload.ts
-import { AsObjectFactory as AsObjectFactory19 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory20 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema19,
+  asSchema as asSchema20,
   isPayloadOfZodType as isPayloadOfZodType15,
-  XyoAddressZod as XyoAddressZod8
+  XyoAddressZod as XyoAddressZod9
 } from "@xyo-network/sdk";
-import { z as z27 } from "zod/mini";
-var SlashEvidenceSchema = asSchema19("network.xyo.chain.slash.evidence", true);
-var SlashEvidenceFieldsZod = z27.object({
+import { z as z28 } from "zod/mini";
+var SlashEvidenceSchema = asSchema20("network.xyo.chain.slash.evidence", true);
+var SlashEvidenceFieldsZod = z28.object({
   /** The signed artifacts, exactly as they were observed. */
-  artifacts: z27.array(z27.record(z27.string(), z27.unknown())),
+  artifacts: z28.array(z28.record(z28.string(), z28.unknown())),
   /** Address that submitted the evidence. */
-  from: XyoAddressZod8
+  from: XyoAddressZod9
 });
 var isSlashEvidence = isPayloadOfZodType15(SlashEvidenceFieldsZod, SlashEvidenceSchema);
-var asSlashEvidence = AsObjectFactory19.create(isSlashEvidence);
+var asSlashEvidence = AsObjectFactory20.create(isSlashEvidence);
 
 // src/modules/protocol-model/payload/slash/SlashRequestPayload.ts
-import { AsObjectFactory as AsObjectFactory20, HashZod as HashZod8 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory21, HashZod as HashZod9 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema20,
+  asSchema as asSchema21,
   isPayloadOfZodType as isPayloadOfZodType16,
-  XyoAddressZod as XyoAddressZod9
+  XyoAddressZod as XyoAddressZod10
 } from "@xyo-network/sdk";
-import { z as z29 } from "zod/mini";
+import { z as z30 } from "zod/mini";
 
 // src/modules/protocol-model/model/OffenseCode.ts
-import { z as z28 } from "zod/mini";
+import { z as z29 } from "zod/mini";
 var OffenseCodes = [
   "equivocation",
   "invalid-block",
@@ -783,41 +815,41 @@ var OffenseCodes = [
   "invalid-slash-request",
   "false-attestation"
 ];
-var OffenseCodeZod = z28.literal(OffenseCodes);
+var OffenseCodeZod = z29.literal(OffenseCodes);
 
 // src/modules/protocol-model/payload/slash/SlashRequestPayload.ts
-var SlashRequestSchema = asSchema20("network.xyo.chain.slash.request", true);
-var SlashRequestFieldsZod = z29.object({
+var SlashRequestSchema = asSchema21("network.xyo.chain.slash.request", true);
+var SlashRequestFieldsZod = z30.object({
   /** Address accused of the offense. */
-  accused: XyoAddressZod9,
+  accused: XyoAddressZod10,
   /** Height the offense occurred at. */
   block: XL1BlockNumberZod,
   /** Catalog version the offense is judged under. */
-  catalog: z29.number().check(z29.multipleOf(1), z29.positive()),
+  catalog: z30.number().check(z30.multipleOf(1), z30.positive()),
   /** Chain the offense occurred on. */
   chain: ChainIdZod,
   /** Hashes of the artifacts proving the offense, carried in accompanying evidence payloads. */
-  evidence: z29.array(HashZod8),
+  evidence: z30.array(HashZod9),
   /** EVM height the claim is judged against, for anchor and eligibility offenses. */
-  evm: z29.optional(z29.number()),
+  evm: z30.optional(z30.number()),
   /** Address filing the report. */
-  from: XyoAddressZod9,
+  from: XyoAddressZod10,
   /** Offense class being alleged. */
   offense: OffenseCodeZod
 });
 var isSlashRequest = isPayloadOfZodType16(SlashRequestFieldsZod, SlashRequestSchema);
-var asSlashRequest = AsObjectFactory20.create(isSlashRequest);
+var asSlashRequest = AsObjectFactory21.create(isSlashRequest);
 
 // src/modules/protocol-model/payload/StepIdentityPayload.ts
-import { AsObjectFactory as AsObjectFactory21 } from "@ariestools/sdk";
-import { asSchema as asSchema21, isPayloadOfZodType as isPayloadOfZodType17 } from "@xyo-network/sdk";
+import { AsObjectFactory as AsObjectFactory22 } from "@ariestools/sdk";
+import { asSchema as asSchema22, isPayloadOfZodType as isPayloadOfZodType17 } from "@xyo-network/sdk";
 
 // src/modules/protocol-model/Step/StepIdentity.ts
 import { isUndefined } from "@ariestools/sdk";
-import { z as z30 } from "zod";
-var StepIdentityZod = z30.object({
+import { z as z31 } from "zod";
+var StepIdentityZod = z31.object({
   block: XL1BlockNumberZod.describe("The block number at which the step occurs"),
-  step: z30.number().int().nonnegative().describe("The index of the step into the StepSize array")
+  step: z31.number().int().nonnegative().describe("The index of the step into the StepSize array")
 });
 function tryParseInt(value) {
   if (value === "") return void 0;
@@ -883,33 +915,33 @@ var StepRewardFractions = [
 ];
 
 // src/modules/protocol-model/payload/StepIdentityPayload.ts
-var StepIdentitySchema = asSchema21("network.xyo.chain.step.identity", true);
+var StepIdentitySchema = asSchema22("network.xyo.chain.step.identity", true);
 var isStepIdentityPayload = isPayloadOfZodType17(StepIdentityZod, StepIdentitySchema);
-var asStepIdentityPayload = AsObjectFactory21.create(isStepIdentityPayload);
+var asStepIdentityPayload = AsObjectFactory22.create(isStepIdentityPayload);
 
 // src/modules/protocol-model/payload/StepWitness.ts
-import { AsObjectFactory as AsObjectFactory22, HashZod as HashZod9 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory23, HashZod as HashZod10 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema22,
+  asSchema as asSchema23,
   isPayloadOfZodType as isPayloadOfZodType18,
-  XyoAddressZod as XyoAddressZod10
+  XyoAddressZod as XyoAddressZod11
 } from "@xyo-network/sdk";
-import { z as z31 } from "zod/mini";
-var StepWitnessSchema = asSchema22("network.xyo.chain.validation.step.witness", true);
-var StepWitnessFieldsZod = z31.object({
+import { z as z32 } from "zod/mini";
+var StepWitnessSchema = asSchema23("network.xyo.chain.validation.step.witness", true);
+var StepWitnessFieldsZod = z32.object({
   /** Hash of the block in which the step hash was observed */
-  blockHash: HashZod9,
+  blockHash: HashZod10,
   /** 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: HashZod9,
+  stepHash: HashZod10,
   /** Block-interval size of the observed step level — must be one of StepSizes */
-  stepSize: z31.literal(StepSizes),
+  stepSize: z32.literal(StepSizes),
   /** Address of the observer */
-  witness: XyoAddressZod10
+  witness: XyoAddressZod11
 });
 var isStepWitness = isPayloadOfZodType18(StepWitnessFieldsZod, StepWitnessSchema);
-var asStepWitness = AsObjectFactory22.create(isStepWitness);
+var asStepWitness = AsObjectFactory23.create(isStepWitness);
 
 // src/modules/protocol-model/transaction/TransactionGasCosts.ts
 var TransactionGasCosts = {
@@ -930,32 +962,32 @@ var TransactionGasCosts = {
 
 // src/modules/protocol-model/TransferPayload.ts
 import {
-  AsObjectFactory as AsObjectFactory23,
+  AsObjectFactory as AsObjectFactory24,
   HexZod as HexZod6,
   JsonObjectZod,
-  zodIsFactory as zodIsFactory4
+  zodIsFactory as zodIsFactory5
 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema23,
-  isPayloadOfSchemaType as isPayloadOfSchemaType5,
-  PayloadZodOfSchema as PayloadZodOfSchema2,
-  XyoAddressZod as XyoAddressZod11
+  asSchema as asSchema24,
+  isPayloadOfSchemaType as isPayloadOfSchemaType6,
+  PayloadZodOfSchema as PayloadZodOfSchema3,
+  XyoAddressZod as XyoAddressZod12
 } from "@xyo-network/sdk";
-import { z as z32 } from "zod/mini";
-var TransferSchema = asSchema23("network.xyo.transfer", true);
-var TransferFieldsZod = z32.object({
+import { z as z33 } from "zod/mini";
+var TransferSchema = asSchema24("network.xyo.transfer", true);
+var TransferFieldsZod = z33.object({
   // Removed as only transaction have opCodes
   // $opCodes: z.array(z.string()).optional(),
-  context: z32.optional(JsonObjectZod),
-  epoch: z32.number(),
-  from: XyoAddressZod11,
-  transfers: z32.record(XyoAddressZod11, HexZod6)
+  context: z33.optional(JsonObjectZod),
+  epoch: z33.number(),
+  from: XyoAddressZod12,
+  transfers: z33.record(XyoAddressZod12, HexZod6)
 });
-var TransferZod = z32.extend(PayloadZodOfSchema2(TransferSchema), TransferFieldsZod.shape);
-var isTransfer = isPayloadOfSchemaType5(TransferSchema);
-var isTransferPayload = zodIsFactory4(TransferZod);
-var asTransfer = AsObjectFactory23.create(isTransfer);
-var asTransferPayload = AsObjectFactory23.create(isTransferPayload);
+var TransferZod = z33.extend(PayloadZodOfSchema3(TransferSchema), TransferFieldsZod.shape);
+var isTransfer = isPayloadOfSchemaType6(TransferSchema);
+var isTransferPayload = zodIsFactory5(TransferZod);
+var asTransfer = AsObjectFactory24.create(isTransfer);
+var asTransferPayload = AsObjectFactory24.create(isTransferPayload);
 
 // src/modules/protocol-model/block/AllowedBlockPayload.ts
 var AllowedBlockPayloadSchemas = [
@@ -964,6 +996,7 @@ var AllowedBlockPayloadSchemas = [
   BridgeIntentSchema,
   BridgeSourceObservationSchema,
   ChainStakeIntentSchema,
+  ClaimSchema,
   HashSchema,
   SchemaSchema,
   SlashAdjudicationSchema,
@@ -976,10 +1009,10 @@ var AllowedBlockPayloadSchemas = [
   TimeSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadSchemaZod = z33.enum(AllowedBlockPayloadSchemas);
-var isAllowedBlockPayloadSchema = zodIsFactory5(AllowedBlockPayloadSchemaZod);
+var AllowedBlockPayloadSchemaZod = z34.enum(AllowedBlockPayloadSchemas);
+var isAllowedBlockPayloadSchema = zodIsFactory6(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (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);
+  return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isClaim(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);
@@ -987,9 +1020,9 @@ var isAllowedBlockPayloadWithHashMeta = (value) => {
 
 // src/modules/protocol-model/block/BlockBoundWitness.ts
 import {
-  HashZod as HashZod10,
+  HashZod as HashZod11,
   zodAsFactory as zodAsFactory7,
-  zodIsFactory as zodIsFactory6,
+  zodIsFactory as zodIsFactory7,
   zodToFactory as zodToFactory7
 } from "@ariestools/sdk";
 import {
@@ -997,13 +1030,13 @@ import {
   WithHashMetaZod as WithHashMetaZod2,
   WithStorageMetaZod as WithStorageMetaZod2
 } from "@xyo-network/sdk";
-import { z as z34 } from "zod/mini";
-var BlockBoundWitnessFieldsZod = z34.object({
+import { z as z35 } from "zod/mini";
+var BlockBoundWitnessFieldsZod = z35.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: z34.nullable(HashZod10),
-  protocol: z34.optional(z34.number()),
-  step_hashes: z34.optional(z34.array(HashZod10)),
+  previous: z35.nullable(HashZod11),
+  protocol: z35.optional(z35.number()),
+  step_hashes: z35.optional(z35.array(HashZod11)),
   /**
    * Signed hash of the same-height candidate this block replaces.
    *
@@ -1011,30 +1044,30 @@ var BlockBoundWitnessFieldsZod = z34.object({
    * 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)
+  supersedes: z35.optional(HashZod11)
 });
-var BlockBoundWitnessMetaZod = z34.object({ $epoch: z34.number() });
-var BlockBoundWitnessZod = z34.object({
+var BlockBoundWitnessMetaZod = z35.object({ $epoch: z35.number() });
+var BlockBoundWitnessZod = z35.object({
   ...BoundWitnessZod2.shape,
   ...BlockBoundWitnessFieldsZod.shape,
   ...BlockBoundWitnessMetaZod.shape
 });
-var isBlockBoundWitness = zodIsFactory6(BlockBoundWitnessZod);
+var isBlockBoundWitness = zodIsFactory7(BlockBoundWitnessZod);
 var asBlockBoundWitness = zodAsFactory7(BlockBoundWitnessZod, "asBlockBoundWitness");
 var toBlockBoundWitness = zodToFactory7(BlockBoundWitnessZod, "toBlockBoundWitness");
 var BlockBoundWitnessWithHashMetaZod = WithHashMetaZod2(BlockBoundWitnessZod);
-var isBlockBoundWitnessWithHashMeta = zodIsFactory6(WithHashMetaZod2(BlockBoundWitnessZod));
+var isBlockBoundWitnessWithHashMeta = zodIsFactory7(WithHashMetaZod2(BlockBoundWitnessZod));
 var asBlockBoundWitnessWithHashMeta = zodAsFactory7(WithHashMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithHashMeta");
 var toBlockBoundWitnessWithHashMeta = zodToFactory7(WithHashMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithHashMeta");
 var BlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod2(BlockBoundWitnessZod);
-var isBlockBoundWitnessWithStorageMeta = zodIsFactory6(WithStorageMetaZod2(BlockBoundWitnessZod));
+var isBlockBoundWitnessWithStorageMeta = zodIsFactory7(WithStorageMetaZod2(BlockBoundWitnessZod));
 var asBlockBoundWitnessWithStorageMeta = zodAsFactory7(WithStorageMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithStorageMeta");
 var toBlockBoundWitnessWithStorageMeta = zodToFactory7(WithStorageMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithStorageMeta");
 
 // src/modules/protocol-model/block/HydratedBlock.ts
 import {
   zodAsFactory as zodAsFactory11,
-  zodIsFactory as zodIsFactory10,
+  zodIsFactory as zodIsFactory11,
   zodToFactory as zodToFactory11
 } from "@ariestools/sdk";
 import {
@@ -1043,38 +1076,38 @@ import {
   WithHashMetaZod as WithHashMetaZod4,
   WithStorageMetaZod as WithStorageMetaZod4
 } from "@xyo-network/sdk";
-import { z as z38 } from "zod/mini";
+import { z as z39 } from "zod/mini";
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitness.ts
 import {
   zodAsFactory as zodAsFactory8,
-  zodIsFactory as zodIsFactory7,
+  zodIsFactory as zodIsFactory8,
   zodToFactory as zodToFactory8
 } from "@ariestools/sdk";
 import { SignedBoundWitnessZod as SignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z35 } from "zod/mini";
-var SignedBlockBoundWitnessZod = z35.safeExtend(
-  z35.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z36 } from "zod/mini";
+var SignedBlockBoundWitnessZod = z36.safeExtend(
+  z36.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
-var isSignedBlockBoundWitness = zodIsFactory7(SignedBlockBoundWitnessZod);
+var isSignedBlockBoundWitness = zodIsFactory8(SignedBlockBoundWitnessZod);
 var asSignedBlockBoundWitness = zodAsFactory8(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
 var toSignedBlockBoundWitness = zodToFactory8(SignedBlockBoundWitnessZod, "toSignedBlockBoundWitness");
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithHashMeta.ts
 import {
   zodAsFactory as zodAsFactory9,
-  zodIsFactory as zodIsFactory8,
+  zodIsFactory as zodIsFactory9,
   zodToFactory as zodToFactory9
 } from "@ariestools/sdk";
 import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk";
-import { z as z36 } from "zod/mini";
+import { z as z37 } from "zod/mini";
 var SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod3(SignedBlockBoundWitnessZod);
-var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory8(SignedBlockBoundWitnessWithHashMetaZod);
+var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory9(SignedBlockBoundWitnessWithHashMetaZod);
 var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory9(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
-var SignedBlockBoundWitnessWithHashMetaishZod = z36.pipe(
+var SignedBlockBoundWitnessWithHashMetaishZod = z37.pipe(
   SignedBlockBoundWitnessZod,
-  z36.transform(async (data) => {
+  z37.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithHashMeta(data)) {
       return data;
     }
@@ -1089,20 +1122,20 @@ var toSignedBlockBoundWitnessWithHashMeta = zodToFactory9(SignedBlockBoundWitnes
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts
 import {
   zodAsFactory as zodAsFactory10,
-  zodIsFactory as zodIsFactory9,
+  zodIsFactory as zodIsFactory10,
   zodToFactory as zodToFactory10
 } from "@ariestools/sdk";
 import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod3 } from "@xyo-network/sdk";
-import { z as z37 } from "zod/mini";
+import { z as z38 } from "zod/mini";
 var SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod3(SignedBlockBoundWitnessZod);
-var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory9(SignedBlockBoundWitnessWithStorageMetaZod);
+var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory10(SignedBlockBoundWitnessWithStorageMetaZod);
 var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory10(
   SignedBlockBoundWitnessWithStorageMetaZod,
   "asSignedBlockBoundWitnessWithStorageMeta"
 );
-var SignedBlockBoundWitnessWithStorageMetaishZod = z37.pipe(
+var SignedBlockBoundWitnessWithStorageMetaishZod = z38.pipe(
   SignedBlockBoundWitnessZod,
-  z37.transform(async (data) => {
+  z38.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
       return data;
     }
@@ -1118,128 +1151,128 @@ var toSignedBlockBoundWitnessWithStorageMeta = zodToFactory10(
 );
 
 // src/modules/protocol-model/block/HydratedBlock.ts
-var HydratedBlockZod = z38.tuple([
+var HydratedBlockZod = z39.tuple([
   BlockBoundWitnessZod,
-  z38.array(PayloadZodLoose)
+  z39.array(PayloadZodLoose)
 ]);
-var isHydratedBlock = zodIsFactory10(HydratedBlockZod);
+var isHydratedBlock = zodIsFactory11(HydratedBlockZod);
 var asHydratedBlock = zodAsFactory11(HydratedBlockZod, "asHydratedBlock");
 var toHydratedBlock = zodToFactory11(HydratedBlockZod, "toHydratedBlock");
-var HydratedBlockWithHashMetaZod = z38.tuple([
+var HydratedBlockWithHashMetaZod = z39.tuple([
   WithHashMetaZod4(BlockBoundWitnessZod),
-  z38.array(z38.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z39.array(z39.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var isHydratedBlockWithHashMeta = zodIsFactory10(HydratedBlockWithHashMetaZod);
+var isHydratedBlockWithHashMeta = zodIsFactory11(HydratedBlockWithHashMetaZod);
 var asHydratedBlockWithHashMeta = zodAsFactory11(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
 var toHydratedBlockWithHashMeta = zodToFactory11(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
-var HydratedBlockWithStorageMetaZod = z38.tuple([
+var HydratedBlockWithStorageMetaZod = z39.tuple([
   WithStorageMetaZod4(BlockBoundWitnessZod),
-  z38.array(z38.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z39.array(z39.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
-var isHydratedBlockWithStorageMeta = zodIsFactory10(HydratedBlockWithStorageMetaZod);
+var isHydratedBlockWithStorageMeta = zodIsFactory11(HydratedBlockWithStorageMetaZod);
 var asHydratedBlockWithStorageMeta = zodAsFactory11(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
 var toHydratedBlockWithStorageMeta = zodToFactory11(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
-var SignedHydratedBlockZod = z38.tuple([
+var SignedHydratedBlockZod = z39.tuple([
   SignedBlockBoundWitnessZod,
-  z38.array(z38.looseObject(PayloadZod.shape))
+  z39.array(z39.looseObject(PayloadZod.shape))
 ]);
-var isSignedHydratedBlock = zodIsFactory10(SignedHydratedBlockZod);
+var isSignedHydratedBlock = zodIsFactory11(SignedHydratedBlockZod);
 var asSignedHydratedBlock = zodAsFactory11(SignedHydratedBlockZod, "asSignedHydratedBlock");
 var toSignedHydratedBlock = zodToFactory11(SignedHydratedBlockZod, "toSignedHydratedBlock");
-var SignedHydratedBlockToJsonZod = z38.tuple([
+var SignedHydratedBlockToJsonZod = z39.tuple([
   SignedBlockBoundWitnessZod,
-  z38.array(z38.looseObject(PayloadZod.shape))
+  z39.array(z39.looseObject(PayloadZod.shape))
 ]);
-var isSignedHydratedBlockToJson = zodIsFactory10(SignedHydratedBlockToJsonZod);
+var isSignedHydratedBlockToJson = zodIsFactory11(SignedHydratedBlockToJsonZod);
 var asSignedHydratedBlockToJson = zodAsFactory11(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
 var toSignedHydratedBlockToJson = zodToFactory11(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
-var SignedHydratedBlockWithHashMetaZod = z38.tuple([
+var SignedHydratedBlockWithHashMetaZod = z39.tuple([
   WithHashMetaZod4(SignedBlockBoundWitnessZod),
-  z38.array(z38.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z39.array(z39.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var SignedHydratedBlockWithHashMetaishZod = z38.tuple([
-  z38.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
-  z38.array(z38.looseObject(WithHashMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithHashMetaishZod = z39.tuple([
+  z39.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
+  z39.array(z39.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var isSignedHydratedBlockWithHashMeta = zodIsFactory10(SignedHydratedBlockWithHashMetaZod);
+var isSignedHydratedBlockWithHashMeta = zodIsFactory11(SignedHydratedBlockWithHashMetaZod);
 var asSignedHydratedBlockWithHashMeta = zodAsFactory11(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
 var toSignedHydratedBlockWithHashMeta = zodToFactory11(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
-var SignedHydratedBlockWithStorageMetaZod = z38.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z39.tuple([
   WithStorageMetaZod4(SignedBlockBoundWitnessZod),
-  z38.array(z38.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z39.array(z39.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
-var isSignedHydratedBlockWithStorageMeta = zodIsFactory10(SignedHydratedBlockWithStorageMetaZod);
+var isSignedHydratedBlockWithStorageMeta = zodIsFactory11(SignedHydratedBlockWithStorageMetaZod);
 var asSignedHydratedBlockWithStorageMeta = zodAsFactory11(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
 var toSignedHydratedBlockWithStorageMeta = zodToFactory11(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
-var SignedHydratedBlockWithStorageMetaishZod = z38.tuple([
-  z38.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
-  z38.array(z38.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithStorageMetaishZod = z39.tuple([
+  z39.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
+  z39.array(z39.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 
 // src/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.ts
 import {
   zodAsFactory as zodAsFactory12,
-  zodIsFactory as zodIsFactory11,
+  zodIsFactory as zodIsFactory12,
   zodToFactory as zodToFactory12
 } from "@ariestools/sdk";
 import { UnsignedBoundWitnessZod as UnsignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z39 } from "zod/mini";
-var UnsignedBlockBoundWitnessZod = z39.safeExtend(
-  z39.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z40 } from "zod/mini";
+var UnsignedBlockBoundWitnessZod = z40.safeExtend(
+  z40.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
-var isUnsignedBlockBoundWitness = zodIsFactory11(UnsignedBlockBoundWitnessZod);
+var isUnsignedBlockBoundWitness = zodIsFactory12(UnsignedBlockBoundWitnessZod);
 var asUnsignedBlockBoundWitness = zodAsFactory12(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
 var toUnsignedBlockBoundWitness = zodToFactory12(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
 
 // src/modules/protocol-model/evidence/CandidatePairPayload.ts
-import { AsObjectFactory as AsObjectFactory24, HashZod as HashZod11 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory25, HashZod as HashZod12 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema24,
+  asSchema as asSchema25,
   isPayloadOfZodType as isPayloadOfZodType19,
-  XyoAddressZod as XyoAddressZod12
+  XyoAddressZod as XyoAddressZod13
 } from "@xyo-network/sdk";
-import { z as z40 } from "zod/mini";
-var CandidatePairSchema = asSchema24("network.xyo.chain.evidence.candidate.pair", true);
-var CandidatePairFieldsZod = z40.object({
+import { z as z41 } from "zod/mini";
+var CandidatePairSchema = asSchema25("network.xyo.chain.evidence.candidate.pair", true);
+var CandidatePairFieldsZod = z41.object({
   /** Chain both candidates were proposed on */
   chain: ChainIdZod,
   /** Block number both candidates claim */
   height: XL1BlockNumberZod,
   /** Address that signed both candidates */
-  producer: XyoAddressZod12,
+  producer: XyoAddressZod13,
   /** The two candidates' recomputed bound witness data hashes, sorted ascending */
-  subjects: z40.tuple([HashZod11, HashZod11])
+  subjects: z41.tuple([HashZod12, HashZod12])
 });
 var isCandidatePair = isPayloadOfZodType19(CandidatePairFieldsZod, CandidatePairSchema);
-var asCandidatePair = AsObjectFactory24.create(isCandidatePair);
+var asCandidatePair = AsObjectFactory25.create(isCandidatePair);
 
 // src/modules/protocol-model/evidence/CandidateSeenPayload.ts
-import { AsObjectFactory as AsObjectFactory25, HashZod as HashZod12 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory26, HashZod as HashZod13 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema25,
+  asSchema as asSchema26,
   isPayloadOfZodType as isPayloadOfZodType20,
-  XyoAddressZod as XyoAddressZod13
+  XyoAddressZod as XyoAddressZod14
 } from "@xyo-network/sdk";
-import { z as z41 } from "zod/mini";
-var CandidateSeenSchema = asSchema25("network.xyo.chain.evidence.candidate", true);
-var CandidateSeenFieldsZod = z41.object({
+import { z as z42 } from "zod/mini";
+var CandidateSeenSchema = asSchema26("network.xyo.chain.evidence.candidate", true);
+var CandidateSeenFieldsZod = z42.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: z41.optional(HashZod12),
+  previous: z42.optional(HashZod13),
   /** Address that signed the candidate */
-  producer: XyoAddressZod13,
+  producer: XyoAddressZod14,
   /** Recomputed data hash of the candidate's bound witness */
-  subject: HashZod12
+  subject: HashZod13
 });
 var isCandidateSeen = isPayloadOfZodType20(CandidateSeenFieldsZod, CandidateSeenSchema);
-var asCandidateSeen = AsObjectFactory25.create(isCandidateSeen);
+var asCandidateSeen = AsObjectFactory26.create(isCandidateSeen);
 
 // src/modules/protocol-model/evidence/EvidenceDisposition.ts
-import { z as z42 } from "zod/mini";
+import { z as z43 } from "zod/mini";
 var EvidenceDispositions = [
   "expired",
   "finalized",
@@ -1249,55 +1282,55 @@ var EvidenceDispositions = [
   "malformed",
   "superseded"
 ];
-var EvidenceDispositionZod = z42.literal(EvidenceDispositions);
+var EvidenceDispositionZod = z43.literal(EvidenceDispositions);
 
 // src/modules/protocol-model/evidence/EvidenceNotePayload.ts
-import { AsObjectFactory as AsObjectFactory26, HashZod as HashZod13 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory27, HashZod as HashZod14 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema26,
+  asSchema as asSchema27,
   isPayloadOfZodType as isPayloadOfZodType21,
-  XyoAddressZod as XyoAddressZod14
+  XyoAddressZod as XyoAddressZod15
 } from "@xyo-network/sdk";
-import { z as z43 } from "zod/mini";
-var EvidenceNoteSchema = asSchema26("network.xyo.chain.evidence.note", true);
-var EvidenceNoteFieldsZod = z43.object({
+import { z as z44 } from "zod/mini";
+var EvidenceNoteSchema = asSchema27("network.xyo.chain.evidence.note", true);
+var EvidenceNoteFieldsZod = z44.object({
   /** Hash of the stored bundle payload this note describes */
-  bundle: HashZod13,
+  bundle: HashZod14,
   /** Why the candidate left the pending pool */
   disposition: EvidenceDispositionZod,
   /** Block number of the archived candidate — absent when the bundle was malformed */
-  height: z43.optional(XL1BlockNumberZod),
+  height: z44.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: z43.optional(XyoAddressZod14),
+  producer: z44.optional(XyoAddressZod15),
   /** Recomputed data hash of the archived block's bound witness — the artifact identity evidence references use */
-  subject: HashZod13
+  subject: HashZod14
 });
 var isEvidenceNote = isPayloadOfZodType21(EvidenceNoteFieldsZod, EvidenceNoteSchema);
-var asEvidenceNote = AsObjectFactory26.create(isEvidenceNote);
+var asEvidenceNote = AsObjectFactory27.create(isEvidenceNote);
 
 // src/modules/protocol-model/fields/BlockNumber.ts
-import { AsObjectFactory as AsObjectFactory27 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory28 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema27,
-  isPayloadOfSchemaType as isPayloadOfSchemaType6,
+  asSchema as asSchema28,
+  isPayloadOfSchemaType as isPayloadOfSchemaType7,
   isPayloadOfSchemaTypeWithSources
 } from "@xyo-network/sdk";
-var BlockNumberSchema = asSchema27("network.xyo.chain.block.number", true);
-var isBlockNumberPayload = isPayloadOfSchemaType6(BlockNumberSchema);
-var asBlockNumberPayload = AsObjectFactory27.create(isBlockNumberPayload);
+var BlockNumberSchema = asSchema28("network.xyo.chain.block.number", true);
+var isBlockNumberPayload = isPayloadOfSchemaType7(BlockNumberSchema);
+var asBlockNumberPayload = AsObjectFactory28.create(isBlockNumberPayload);
 var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
-var asBlockNumberPayloadWithSources = AsObjectFactory27.create(isBlockNumberPayloadWithSources);
+var asBlockNumberPayloadWithSources = AsObjectFactory28.create(isBlockNumberPayloadWithSources);
 
 // src/modules/protocol-model/model/AccountBalance.ts
-import { zodIsFactory as zodIsFactory14 } from "@ariestools/sdk";
+import { zodIsFactory as zodIsFactory15 } from "@ariestools/sdk";
 import { WithHashMetaZod as WithHashMetaZod5 } from "@xyo-network/sdk";
-import { z as z49 } from "zod/mini";
+import { z as z50 } from "zod/mini";
 
 // src/modules/protocol-model/model/ChainQualification.ts
-import { HashZod as HashZod14, zodIsFactory as zodIsFactory13 } from "@ariestools/sdk";
-import { z as z48 } from "zod";
+import { HashZod as HashZod15, zodIsFactory as zodIsFactory14 } from "@ariestools/sdk";
+import { z as z49 } from "zod";
 
 // src/modules/protocol-model/model/BlockRange/BlockRange.ts
 import {
@@ -1306,9 +1339,9 @@ import {
   zodAsFactory as zodAsFactory13,
   zodToFactory as zodToFactory13
 } from "@ariestools/sdk";
-import { z as z44 } from "zod";
-var BlockRangeZod = z44.tuple([BlockNumberZod, BlockNumberZod]);
-var BlockRangeishZod = z44.tuple([BlockNumberishZod, BlockNumberishZod]);
+import { z as z45 } from "zod";
+var BlockRangeZod = z45.tuple([BlockNumberZod, BlockNumberZod]);
+var BlockRangeishZod = z45.tuple([BlockNumberishZod, BlockNumberishZod]);
 var asBlockRange = zodAsFactory13(BlockRangeZod, "BlockRange");
 var toBlockRange = zodToFactory13(BlockRangeishZod, "BlockRange");
 var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1325,9 +1358,9 @@ import {
   zodAsFactory as zodAsFactory14,
   zodToFactory as zodToFactory14
 } from "@ariestools/sdk";
-import { z as z45 } from "zod";
-var EthBlockRangeZod = z45.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-var EthBlockRangeishZod = z45.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
+import { z as z46 } from "zod";
+var EthBlockRangeZod = z46.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var EthBlockRangeishZod = z46.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
 var asEthBlockRange = zodAsFactory14(EthBlockRangeZod, "EthBlockRange");
 var toEthBlockRange = zodToFactory14(EthBlockRangeishZod, "EthBlockRange");
 var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1340,12 +1373,12 @@ function fromEthBlockNumberKey(key, assert) {
 // src/modules/protocol-model/model/BlockRange/Range.ts
 import {
   zodAsFactory as zodAsFactory15,
-  zodIsFactory as zodIsFactory12,
+  zodIsFactory as zodIsFactory13,
   zodToFactory as zodToFactory15
 } from "@ariestools/sdk";
-import { z as z46 } from "zod";
-var RangeZod = z46.tuple([z46.number(), z46.number()]);
-var isRange = zodIsFactory12(RangeZod);
+import { z as z47 } from "zod";
+var RangeZod = z47.tuple([z47.number(), z47.number()]);
+var isRange = zodIsFactory13(RangeZod);
 var asRange = zodAsFactory15(RangeZod, "Range");
 var toRange = zodToFactory15(RangeZod, "Range");
 
@@ -1356,9 +1389,9 @@ import {
   zodAsFactory as zodAsFactory16,
   zodToFactory as zodToFactory16
 } from "@ariestools/sdk";
-import { z as z47 } from "zod";
-var XL1BlockRangeZod = z47.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-var XL1BlockRangeishZod = z47.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
+import { z as z48 } from "zod";
+var XL1BlockRangeZod = z48.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var XL1BlockRangeishZod = z48.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
 var asXL1BlockRange = zodAsFactory16(XL1BlockRangeZod, "XL1BlockRange");
 var toXL1BlockRange = zodToFactory16(XL1BlockRangeishZod, "XL1BlockRange");
 var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1369,33 +1402,33 @@ function fromXL1BlockNumberKey(key, assert) {
 }
 
 // src/modules/protocol-model/model/ChainQualification.ts
-var ChainQualificationZod = z48.object({ head: HashZod14, range: XL1BlockRangeZod });
-var isChainQualification = zodIsFactory13(ChainQualificationZod);
-var ChainQualifiedRangeConfigZod = z48.object({ range: XL1BlockRangeZod });
-var isChainQualifiedRangeConfig = zodIsFactory13(ChainQualifiedRangeConfigZod);
-var ChainQualifiedHeadConfigZod = z48.object({ head: HashZod14 });
-var isChainQualifiedHeadConfig = zodIsFactory13(ChainQualifiedHeadConfigZod);
-var ChainQualifiedConfigZod = z48.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z48.object({})]);
-var isChainQualifiedConfig = zodIsFactory13(ChainQualifiedConfigZod);
+var ChainQualificationZod = z49.object({ head: HashZod15, range: XL1BlockRangeZod });
+var isChainQualification = zodIsFactory14(ChainQualificationZod);
+var ChainQualifiedRangeConfigZod = z49.object({ range: XL1BlockRangeZod });
+var isChainQualifiedRangeConfig = zodIsFactory14(ChainQualifiedRangeConfigZod);
+var ChainQualifiedHeadConfigZod = z49.object({ head: HashZod15 });
+var isChainQualifiedHeadConfig = zodIsFactory14(ChainQualifiedHeadConfigZod);
+var ChainQualifiedConfigZod = z49.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z49.object({})]);
+var isChainQualifiedConfig = zodIsFactory14(ChainQualifiedConfigZod);
 var ExtendChainQualifiedConfigZod = ((zodType) => {
-  return z48.union([
+  return z49.union([
     ChainQualifiedRangeConfigZod.extend(zodType),
     ChainQualifiedHeadConfigZod.extend(zodType),
     zodType
   ]);
 });
 var ChainQualifiedZod = (zodType) => {
-  return z48.tuple([zodType, ChainQualificationZod]);
+  return z49.tuple([zodType, ChainQualificationZod]);
 };
 
 // src/modules/protocol-model/model/AccountBalance.ts
-var AccountBalanceHistoryItemZod = z49.tuple([
+var AccountBalanceHistoryItemZod = z50.tuple([
   WithHashMetaZod5(BlockBoundWitnessZod),
-  z49.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
+  z50.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
   WithHashMetaZod5(TransferZod)
 ]);
 var AccountBalanceConfigZod = ChainQualifiedConfigZod;
-var isAccountBalanceConfig = zodIsFactory14(AccountBalanceConfigZod);
+var isAccountBalanceConfig = zodIsFactory15(AccountBalanceConfigZod);
 var AccountBalanceViewerMoniker = "AccountBalanceViewer";
 
 // src/modules/protocol-model/model/addresses.ts
@@ -1410,51 +1443,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 z50 } from "zod";
+import { z as z51 } from "zod";
 function base64Encode(u8) {
   return u8.toBase64();
 }
 function base64Decode(b64) {
   return Uint8Array.fromBase64(b64);
 }
-var ArrayBufferToJsonZod = z50.instanceof(ArrayBuffer).transform((x) => {
+var ArrayBufferToJsonZod = z51.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
 });
-var JsonToArrayBufferZod = z50.string().transform((x) => {
+var JsonToArrayBufferZod = z51.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 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()
+import { zodAsFactory as zodAsFactory17, zodIsFactory as zodIsFactory16 } from "@ariestools/sdk";
+import { z as z52 } from "zod";
+var TimeDurationsZod = z52.object({
+  millis: z52.number().nonnegative(),
+  seconds: z52.number().nonnegative(),
+  minutes: z52.number().nonnegative(),
+  hours: z52.number().nonnegative(),
+  days: z52.number().nonnegative(),
+  weeks: z52.number().nonnegative()
 });
-var isTimeDurations = zodIsFactory15(TimeDurationsZod);
+var isTimeDurations = zodIsFactory16(TimeDurationsZod);
 var asTimeDurations = zodAsFactory17(TimeDurationsZod, "asTimeDurations");
 var toTimeDurations = zodAsFactory17(TimeDurationsZod, "toTimeDurations");
-var BlockRateZod = z51.object({
+var BlockRateZod = z52.object({
   range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
-  rate: z51.number().nonnegative().describe("rate of blocks per specified time unit"),
+  rate: z52.number().nonnegative().describe("rate of blocks per specified time unit"),
   timeUnit: TimeDurationsZod.keyof().describe("the unit of time for the rate and timePerBlock"),
-  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")
+  span: z52.int().nonnegative().describe("number of blocks the rate was calculated over"),
+  timeDifference: z52.number().nonnegative().describe("time difference from start and end block"),
+  timePerBlock: z52.number().nonnegative().describe("average time per block for the given range")
 });
-var isBlockRate = zodIsFactory15(BlockRateZod);
+var isBlockRate = zodIsFactory16(BlockRateZod);
 var asBlockRate = zodAsFactory17(BlockRateZod, "asBlockRate");
 var toBlockRate = zodAsFactory17(BlockRateZod, "toBlockRate");
-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({
+var CountZod = z52.int().nonnegative().describe("A non-negative integer count");
+var StepIndexZod = z52.int().min(0).max(StepSizes.length - 1).describe("A non-negative integer step index");
+var timeUnitSchema = z52.number().positive();
+var TimeConfigZod = z52.object({
   minutes: timeUnitSchema.optional(),
   hours: timeUnitSchema.optional(),
   days: timeUnitSchema.optional(),
@@ -1462,33 +1495,33 @@ var TimeConfigZod = z51.object({
   months: timeUnitSchema.optional(),
   years: timeUnitSchema.optional()
 }).describe("Time configuration with optional time units");
-var isTimeConfig = zodIsFactory15(TimeConfigZod);
+var isTimeConfig = zodIsFactory16(TimeConfigZod);
 var asTimeConfig = zodAsFactory17(TimeConfigZod, "asTimeConfig");
 var toTimeConfig = zodAsFactory17(TimeConfigZod, "toTimeConfig");
-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 })
+var SingleTimeConfigZod = z52.union([
+  z52.object({ minutes: timeUnitSchema }),
+  z52.object({ hours: timeUnitSchema }),
+  z52.object({ days: timeUnitSchema }),
+  z52.object({ weeks: timeUnitSchema }),
+  z52.object({ months: timeUnitSchema }),
+  z52.object({ years: timeUnitSchema })
 ]).describe("Time configuration with exactly one time unit");
-var isSingleTimeConfig = zodIsFactory15(SingleTimeConfigZod);
+var isSingleTimeConfig = zodIsFactory16(SingleTimeConfigZod);
 var asSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "asSingleTimeConfig");
 var toSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "toSingleTimeConfig");
 
 // src/modules/protocol-model/model/Context/BaseContext.zod.ts
-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))
+import { z as z53 } from "zod";
+var CachesZod = z53.record(
+  z53.string(),
+  z53.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
 );
-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({
+var SingletonsZod = z53.record(z53.union([z53.string(), z53.symbol()]), z53.unknown());
+var LoggerZod = z53.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
+var MeterProviderZod = z53.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
+var TracerProviderZod = z53.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
+var TimeBudgetLimitZod = z53.number();
+var BaseContextZod = z53.object({
   caches: CachesZod.optional(),
   logger: LoggerZod.optional(),
   meterProvider: MeterProviderZod.optional(),
@@ -1498,24 +1531,24 @@ var BaseContextZod = z52.object({
 });
 
 // src/modules/protocol-model/model/Context/BlockContext.zod.ts
-import z53 from "zod";
+import z54 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: z53.custom((val) => val != null && typeof val === "object" && "get" in val) }
+  { chainMap: z54.custom((val) => val != null && typeof val === "object" && "get" in val) }
 );
 var BlockContextWriteZod = CachingContextZod.extend(
-  { chainMap: z53.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
+  { chainMap: z54.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 z54 from "zod";
-var HeadContextBaseZod = z54.object(
+import z55 from "zod";
+var HeadContextBaseZod = z55.object(
   { head: WithHashMetaZod6(BlockBoundWitnessZod) }
 );
 var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
@@ -1551,7 +1584,7 @@ var defaultTransactionFees = {
 // src/modules/protocol-model/model/HydratedTransaction.ts
 import {
   zodAsFactory as zodAsFactory18,
-  zodIsFactory as zodIsFactory16,
+  zodIsFactory as zodIsFactory17,
   zodToFactory as zodToFactory17
 } from "@ariestools/sdk";
 import {
@@ -1560,47 +1593,47 @@ import {
   WithHashMetaZod as WithHashMetaZod7,
   WithStorageMetaZod as WithStorageMetaZod5
 } from "@xyo-network/sdk";
-import { z as z55 } from "zod/mini";
-var HydratedTransactionZod = z55.tuple([
+import { z as z56 } from "zod/mini";
+var HydratedTransactionZod = z56.tuple([
   TransactionBoundWitnessZod,
-  z55.array(PayloadZodLoose2)
+  z56.array(PayloadZodLoose2)
 ]);
-var isHydratedTransaction = zodIsFactory16(HydratedTransactionZod);
+var isHydratedTransaction = zodIsFactory17(HydratedTransactionZod);
 var asHydratedTransaction = zodAsFactory18(HydratedTransactionZod, "asHydratedTransaction");
 var toHydratedTransaction = zodToFactory17(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z55.tuple([
+var HydratedTransactionWithHashMetaZod = z56.tuple([
   WithHashMetaZod7(TransactionBoundWitnessZod),
-  z55.array(z55.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z56.array(z56.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isHydratedTransactionWithHashMeta = zodIsFactory16(HydratedTransactionWithHashMetaZod);
+var isHydratedTransactionWithHashMeta = zodIsFactory17(HydratedTransactionWithHashMetaZod);
 var asHydratedTransactionWithHashMeta = zodAsFactory18(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
 var toHydratedTransactionWithHashMeta = zodToFactory17(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z55.tuple([
+var HydratedTransactionWithStorageMetaZod = z56.tuple([
   WithStorageMetaZod5(TransactionBoundWitnessZod),
-  z55.array(z55.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z56.array(z56.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isHydratedTransactionWithStorageMeta = zodIsFactory16(HydratedTransactionWithStorageMetaZod);
+var isHydratedTransactionWithStorageMeta = zodIsFactory17(HydratedTransactionWithStorageMetaZod);
 var asHydratedTransactionWithStorageMeta = zodAsFactory18(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
 var toHydratedTransactionWithStorageMeta = zodToFactory17(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z55.tuple([
+var UnsignedHydratedTransactionZod = z56.tuple([
   UnsignedTransactionBoundWitnessZod,
-  z55.array(PayloadZodLoose2)
+  z56.array(PayloadZodLoose2)
 ]);
-var isUnsignedHydratedTransaction = zodIsFactory16(UnsignedHydratedTransactionZod);
+var isUnsignedHydratedTransaction = zodIsFactory17(UnsignedHydratedTransactionZod);
 var asUnsignedHydratedTransaction = zodAsFactory18(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
 var toUnsignedHydratedTransaction = zodToFactory17(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z55.tuple([
+var UnsignedHydratedTransactionWithHashMetaZod = z56.tuple([
   WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
-  z55.array(z55.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z56.array(z56.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory16(UnsignedHydratedTransactionWithHashMetaZod);
+var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory17(UnsignedHydratedTransactionWithHashMetaZod);
 var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory18(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
 var toUnsignedHydratedTransactionWithHashMeta = zodToFactory17(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z55.tuple([
+var UnsignedHydratedTransactionWithStorageMetaZod = z56.tuple([
   WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
-  z55.array(z55.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z56.array(z56.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory16(UnsignedHydratedTransactionWithStorageMetaZod);
+var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory17(UnsignedHydratedTransactionWithStorageMetaZod);
 var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory18(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "asUnsignedHydratedTransactionWithStorageMeta"
@@ -1609,25 +1642,25 @@ var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory17(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z55.tuple([
+var SignedHydratedTransactionZod = z56.tuple([
   SignedTransactionBoundWitnessZod,
-  z55.array(PayloadZodLoose2)
+  z56.array(PayloadZodLoose2)
 ]);
-var isSignedHydratedTransaction = zodIsFactory16(SignedHydratedTransactionZod);
+var isSignedHydratedTransaction = zodIsFactory17(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory18(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var toSignedHydratedTransaction = zodToFactory17(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z55.tuple([
+var SignedHydratedTransactionWithHashMetaZod = z56.tuple([
   WithHashMetaZod7(SignedTransactionBoundWitnessZod),
-  z55.array(z55.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z56.array(z56.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isSignedHydratedTransactionWithHashMeta = zodIsFactory16(SignedHydratedTransactionWithHashMetaZod);
+var isSignedHydratedTransactionWithHashMeta = zodIsFactory17(SignedHydratedTransactionWithHashMetaZod);
 var asSignedHydratedTransactionWithHashMeta = zodAsFactory18(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
 var toSignedHydratedTransactionWithHashMeta = zodToFactory17(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z55.tuple([
+var SignedHydratedTransactionWithStorageMetaZod = z56.tuple([
   WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
-  z55.array(z55.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z56.array(z56.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isSignedHydratedTransactionWithStorageMeta = zodIsFactory16(SignedHydratedTransactionWithStorageMetaZod);
+var isSignedHydratedTransactionWithStorageMeta = zodIsFactory17(SignedHydratedTransactionWithStorageMetaZod);
 var asSignedHydratedTransactionWithStorageMeta = zodAsFactory18(
   SignedHydratedTransactionWithStorageMetaZod,
   "asSignedHydratedTransactionWithStorageMeta"
@@ -1641,22 +1674,22 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory17(
 var ELEVATE_OPCODE = "elevate";
 
 // src/modules/protocol-model/model/Permission.ts
-import { z as z56 } from "zod";
-var CaveatTypesZod = z56.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z56.object({
+import { z as z57 } from "zod";
+var CaveatTypesZod = z57.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z57.object({
   type: CaveatTypesZod,
-  value: z56.json()
+  value: z57.json()
 });
-var PermissionZod = z56.object({
-  parentCapability: z56.string(),
+var PermissionZod = z57.object({
+  parentCapability: z57.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z56.string()
+  invoker: z57.string()
 });
-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()
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z57.number().optional() });
+var PermissionRequestZod = z57.record(z57.string(), z57.record(z57.string(), z57.any()));
+var RequestedPermissionZod = z57.object({
+  parentCapability: z57.string(),
+  date: z57.number().optional()
 });
 
 // src/modules/protocol-model/model/rewards.ts
@@ -1670,13 +1703,13 @@ 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 XyoAddressZod15 } from "@xyo-network/sdk";
-import { z as z57 } from "zod";
-var RewardsRangeOptionsZod = z57.object({
-  positions: z57.array(z57.number()).optional(),
+import { XyoAddressZod as XyoAddressZod16 } from "@xyo-network/sdk";
+import { z as z58 } from "zod";
+var RewardsRangeOptionsZod = z58.object({
+  positions: z58.array(z58.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z57.array(StepIdentityZod).optional(),
-  stakers: z57.array(XyoAddressZod15).optional()
+  steps: z58.array(StepIdentityZod).optional(),
+  stakers: z58.array(XyoAddressZod16).optional()
 });
 
 // src/modules/protocol-model/model/RuleActivation.ts
@@ -1718,42 +1751,42 @@ function isRuleObservedAt(params, ruleId, height) {
 // src/modules/protocol-model/model/Sequence.ts
 import { HexRegExMinMax, toHex } from "@ariestools/sdk";
 import { SequenceConstants } from "@xyo-network/sdk";
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z58.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z58.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z59.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z59.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-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]);
+var QualifiedSequenceToStringZod = z59.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z59.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z59.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z59.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
 
 // src/modules/protocol-model/model/Stake.ts
 import { HexZod as HexZod7 } from "@ariestools/sdk";
-import { XyoAddressZod as XyoAddressZod16 } from "@xyo-network/sdk";
-import { z as z59 } from "zod";
-var StakeZod = z59.object({
+import { XyoAddressZod as XyoAddressZod17 } from "@xyo-network/sdk";
+import { z as z60 } from "zod";
+var StakeZod = z60.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z59.number(),
+  addBlock: z60.number(),
   // the unique id for the stake item
-  id: z59.number(),
+  id: z60.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z59.number(),
+  removeBlock: z60.number(),
   // the address that is being staked
-  staked: XyoAddressZod16,
+  staked: XyoAddressZod17,
   // the address that owns the stake
-  staker: XyoAddressZod16,
+  staker: XyoAddressZod17,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z59.number()
+  withdrawBlock: z60.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
   amount: BigIntToJsonZod2.parse(val.amount),
   id: val.id,
   removeBlock: val.removeBlock,
-  staked: XyoAddressZod16.parse(val.staked),
-  staker: XyoAddressZod16.parse(val.staker),
+  staked: XyoAddressZod17.parse(val.staked),
+  staker: XyoAddressZod17.parse(val.staker),
   withdrawBlock: val.withdrawBlock
 }));
 var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
@@ -1769,76 +1802,76 @@ var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
 // src/modules/protocol-model/model/SyncStepSummary.ts
 import {
   zodAsFactory as zodAsFactory19,
-  zodIsFactory as zodIsFactory17,
+  zodIsFactory as zodIsFactory18,
   zodToFactory as zodToFactory18
 } from "@ariestools/sdk";
-import { z as z60 } from "zod";
-var SyncStepSummaryMetadataZod = z60.object({
+import { z as z61 } from "zod";
+var SyncStepSummaryMetadataZod = z61.object({
   block: XL1BlockNumberZod,
-  blockCount: z60.int().nonnegative(),
-  bytes: z60.int().nonnegative(),
-  createdAt: z60.string(),
+  blockCount: z61.int().nonnegative(),
+  bytes: z61.int().nonnegative(),
+  createdAt: z61.string(),
   endBlock: XL1BlockNumberZod,
-  relativePath: z60.string(),
+  relativePath: z61.string(),
   startBlock: XL1BlockNumberZod,
-  step: z60.int().nonnegative(),
+  step: z61.int().nonnegative(),
   stepSize: XL1BlockNumberZod,
-  updatedAt: z60.string()
+  updatedAt: z61.string()
 });
-var isSyncStepSummaryMetadata = zodIsFactory17(SyncStepSummaryMetadataZod);
+var isSyncStepSummaryMetadata = zodIsFactory18(SyncStepSummaryMetadataZod);
 var asSyncStepSummaryMetadata = zodAsFactory19(SyncStepSummaryMetadataZod, "asSyncStepSummaryMetadata");
 var toSyncStepSummaryMetadata = zodToFactory18(SyncStepSummaryMetadataZod, "toSyncStepSummaryMetadata");
-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 SyncStepSummaryStatusZod = z61.object({
+  currentBlock: z61.optional(XL1BlockNumberZod),
+  isIndexing: z61.boolean(),
+  nextBoundaries: z61.record(z61.string(), XL1BlockNumberZod),
+  summaries: z61.array(SyncStepSummaryMetadataZod),
+  summaryCount: z61.int().nonnegative()
 });
-var isSyncStepSummaryStatus = zodIsFactory17(SyncStepSummaryStatusZod);
+var isSyncStepSummaryStatus = zodIsFactory18(SyncStepSummaryStatusZod);
 var asSyncStepSummaryStatus = zodAsFactory19(SyncStepSummaryStatusZod, "asSyncStepSummaryStatus");
 var toSyncStepSummaryStatus = zodToFactory18(SyncStepSummaryStatusZod, "toSyncStepSummaryStatus");
-var SyncStepSummaryZod = z60.array(SignedHydratedBlockWithHashMetaZod);
-var isSyncStepSummary = zodIsFactory17(SyncStepSummaryZod);
+var SyncStepSummaryZod = z61.array(SignedHydratedBlockWithHashMetaZod);
+var isSyncStepSummary = zodIsFactory18(SyncStepSummaryZod);
 var asSyncStepSummary = zodAsFactory19(SyncStepSummaryZod, "asSyncStepSummary");
 var toSyncStepSummary = zodToFactory18(SyncStepSummaryZod, "toSyncStepSummary");
 
 // src/modules/protocol-model/model/TimeDomain.ts
-import { z as z61 } from "zod";
-var TimeDomainZod = z61.union([
-  z61.literal("xl1"),
-  z61.literal("epoch"),
-  z61.literal("ethereum")
+import { z as z62 } from "zod";
+var TimeDomainZod = z62.union([
+  z62.literal("xl1"),
+  z62.literal("epoch"),
+  z62.literal("ethereum")
 ]);
 
 // src/modules/protocol-model/model/TransactionInclusion.ts
 import {
-  HashZod as HashZod15,
+  HashZod as HashZod16,
   zodAsFactory as zodAsFactory20,
-  zodIsFactory as zodIsFactory18,
+  zodIsFactory as zodIsFactory19,
   zodToFactory as zodToFactory19
 } from "@ariestools/sdk";
-import { z as z62 } from "zod";
-var TransactionInclusionZod = z62.object({
+import { z as z63 } from "zod";
+var TransactionInclusionZod = z63.object({
   /** Hash of the finalized block containing the transaction. */
-  blockHash: HashZod15,
+  blockHash: HashZod16,
   /** Number of the finalized block containing the transaction. */
   blockNumber: XL1BlockNumberZod,
   /** Hash of the included transaction. */
-  transactionHash: HashZod15,
+  transactionHash: HashZod16,
   /** Zero-based transaction position within the block. */
-  transactionIndex: z62.int().nonnegative()
+  transactionIndex: z63.int().nonnegative()
 });
-var isTransactionInclusion = zodIsFactory18(TransactionInclusionZod);
+var isTransactionInclusion = zodIsFactory19(TransactionInclusionZod);
 var asTransactionInclusion = zodAsFactory20(TransactionInclusionZod, "asTransactionInclusion");
 var toTransactionInclusion = zodToFactory19(TransactionInclusionZod, "toTransactionInclusion");
 
 // src/modules/protocol-model/model/TransferPair.ts
-import { XyoAddressZod as XyoAddressZod17 } from "@xyo-network/sdk";
-import { z as z63 } from "zod";
-var TransferPairZod = z63.tuple([
-  XyoAddressZod17,
-  XyoAddressZod17
+import { XyoAddressZod as XyoAddressZod18 } from "@xyo-network/sdk";
+import { z as z64 } from "zod";
+var TransferPairZod = z64.tuple([
+  XyoAddressZod18,
+  XyoAddressZod18
 ]);
 
 // src/modules/protocol-model/model/version.ts
@@ -1857,57 +1890,57 @@ var asProviderMoniker = (value) => {
 var DefaultProviderMoniker = "Provider";
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory28 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory29 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema28,
-  isPayloadOfSchemaType as isPayloadOfSchemaType7,
-  PayloadZodOfSchema as PayloadZodOfSchema3
+  asSchema as asSchema29,
+  isPayloadOfSchemaType as isPayloadOfSchemaType8,
+  PayloadZodOfSchema as PayloadZodOfSchema4
 } from "@xyo-network/sdk";
-import { z as z65 } from "zod/mini";
+import { z as z66 } from "zod/mini";
 
 // src/modules/protocol-model/rejection/RejectionError.ts
-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()
+import { HashZod as HashZod17 } from "@ariestools/sdk";
+import { z as z65 } from "zod";
+var RejectionErrorZod = z65.object({
+  hash: HashZod17,
+  message: z65.string().optional(),
+  name: z65.string()
 }).loose();
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-var BlockRejectionSchema = asSchema28("network.xyo.block.rejection", true);
-var BlockRejectionFieldsZod = z65.object({
+var BlockRejectionSchema = asSchema29("network.xyo.block.rejection", true);
+var BlockRejectionFieldsZod = z66.object({
   block: HydratedBlockZod,
-  errors: z65.array(RejectionErrorZod),
-  rejector: z65.string()
+  errors: z66.array(RejectionErrorZod),
+  rejector: z66.string()
 });
-var BlockRejectionZod = z65.extend(
-  PayloadZodOfSchema3(BlockRejectionSchema),
+var BlockRejectionZod = z66.extend(
+  PayloadZodOfSchema4(BlockRejectionSchema),
   BlockRejectionFieldsZod.shape
 );
-var isBlockRejection = isPayloadOfSchemaType7(BlockRejectionSchema);
-var asBlockRejection = AsObjectFactory28.create(isBlockRejection);
+var isBlockRejection = isPayloadOfSchemaType8(BlockRejectionSchema);
+var asBlockRejection = AsObjectFactory29.create(isBlockRejection);
 
 // src/modules/protocol-model/rejection/TransactionRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory29 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory30 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema29,
-  isPayloadOfSchemaType as isPayloadOfSchemaType8,
-  PayloadZodOfSchema as PayloadZodOfSchema4
+  asSchema as asSchema30,
+  isPayloadOfSchemaType as isPayloadOfSchemaType9,
+  PayloadZodOfSchema as PayloadZodOfSchema5
 } from "@xyo-network/sdk";
-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(),
+import { z as z67 } from "zod/mini";
+var TransactionRejectionSchema = asSchema30("network.xyo.transaction.rejection", true);
+var TransactionRejectionFieldsZod = z67.object({
+  errors: z67.array(RejectionErrorZod),
+  rejector: z67.string(),
   transaction: HydratedTransactionZod
 });
-var TransactionRejectionZod = z66.extend(
-  PayloadZodOfSchema4(TransactionRejectionSchema),
+var TransactionRejectionZod = z67.extend(
+  PayloadZodOfSchema5(TransactionRejectionSchema),
   TransactionRejectionFieldsZod.shape
 );
-var isTransactionRejection = isPayloadOfSchemaType8(TransactionRejectionSchema);
-var asTransactionRejection = AsObjectFactory29.create(isTransactionRejection);
+var isTransactionRejection = isPayloadOfSchemaType9(TransactionRejectionSchema);
+var asTransactionRejection = AsObjectFactory30.create(isTransactionRejection);
 export {
   AccountBalanceConfigZod,
   AccountBalanceHistoryItemZod,
@@ -1971,6 +2004,9 @@ export {
   ChainQualifiedZod,
   ChainStakeIntentSchema,
   ChainZod,
+  ClaimFieldsZod,
+  ClaimSchema,
+  ClaimZod,
   CountZod,
   DefaultProviderMoniker,
   ELEVATE_OPCODE,
@@ -2010,6 +2046,7 @@ export {
   LocalSequenceFromStringZod,
   LocalSequenceToStringZod,
   LoggerZod,
+  MAX_CLAIM_HASHES,
   MAX_SAFE_EPOCH,
   MeterProviderZod,
   MicroXL1,
@@ -2172,6 +2209,8 @@ export {
   asCandidateSeen,
   asChainId,
   asChainStakeIntent,
+  asClaim,
+  asClaimPayload,
   asEthBlockNumber,
   asEthBlockRange,
   asEvidenceNote,
@@ -2279,6 +2318,8 @@ export {
   isChainQualifiedRangeConfig,
   isChainStakeIntent,
   isChainStakeIntentWithStorageMeta,
+  isClaim,
+  isClaimPayload,
   isEvidenceNote,
   isExchangeOutcome,
   isExchangeTerms,