@xyo-network/xl1-protocol 5.1.2 → 5.1.3

package/dist/neutral/protocol-model.mjs

@@ -1046,27 +1046,112 @@ var isUnsignedBlockBoundWitness = zodIsFactory11(UnsignedBlockBoundWitnessZod);
 var asUnsignedBlockBoundWitness = zodAsFactory12(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
 var toUnsignedBlockBoundWitness = zodToFactory12(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
 
-// src/modules/protocol-model/fields/BlockNumber.ts
-import { AsObjectFactory as AsObjectFactory19 } from "@ariestools/sdk";
+// src/modules/protocol-model/evidence/CandidatePairPayload.ts
+import { AsObjectFactory as AsObjectFactory19, HashZod as HashZod7 } from "@ariestools/sdk";
 import {
   asSchema as asSchema19,
+  isPayloadOfZodType as isPayloadOfZodType14,
+  XyoAddressZod as XyoAddressZod7
+} 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({
+  /** Chain both candidates were proposed on */
+  chain: ChainIdZod,
+  /** Block number both candidates claim */
+  height: XL1BlockNumberZod,
+  /** Address that signed both candidates */
+  producer: XyoAddressZod7,
+  /** The two candidates' recomputed bound witness data hashes, sorted ascending */
+  subjects: z34.tuple([HashZod7, HashZod7])
+});
+var isCandidatePair = isPayloadOfZodType14(CandidatePairFieldsZod, CandidatePairSchema);
+var asCandidatePair = AsObjectFactory19.create(isCandidatePair);
+
+// src/modules/protocol-model/evidence/CandidateSeenPayload.ts
+import { AsObjectFactory as AsObjectFactory20, HashZod as HashZod8 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema20,
+  isPayloadOfZodType as isPayloadOfZodType15,
+  XyoAddressZod as XyoAddressZod8
+} from "@xyo-network/sdk";
+import { z as z35 } from "zod/mini";
+var CandidateSeenSchema = asSchema20("network.xyo.chain.evidence.candidate", true);
+var CandidateSeenFieldsZod = z35.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),
+  /** Address that signed the candidate */
+  producer: XyoAddressZod8,
+  /** Recomputed data hash of the candidate's bound witness */
+  subject: HashZod8
+});
+var isCandidateSeen = isPayloadOfZodType15(CandidateSeenFieldsZod, CandidateSeenSchema);
+var asCandidateSeen = AsObjectFactory20.create(isCandidateSeen);
+
+// src/modules/protocol-model/evidence/EvidenceDisposition.ts
+import { z as z36 } from "zod/mini";
+var EvidenceDispositions = [
+  "expired",
+  "finalized",
+  "foreign",
+  "invalid",
+  "losing",
+  "malformed",
+  "superseded"
+];
+var EvidenceDispositionZod = z36.literal(EvidenceDispositions);
+
+// src/modules/protocol-model/evidence/EvidenceNotePayload.ts
+import { AsObjectFactory as AsObjectFactory21, HashZod as HashZod9 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema21,
+  isPayloadOfZodType as isPayloadOfZodType16,
+  XyoAddressZod as XyoAddressZod9
+} from "@xyo-network/sdk";
+import { z as z37 } from "zod/mini";
+var EvidenceNoteSchema = asSchema21("network.xyo.chain.evidence.note", true);
+var EvidenceNoteFieldsZod = z37.object({
+  /** Hash of the stored bundle payload this note describes */
+  bundle: HashZod9,
+  /** 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),
+  /** 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),
+  /** Recomputed data hash of the archived block's bound witness — the artifact identity evidence references use */
+  subject: HashZod9
+});
+var isEvidenceNote = isPayloadOfZodType16(EvidenceNoteFieldsZod, EvidenceNoteSchema);
+var asEvidenceNote = AsObjectFactory21.create(isEvidenceNote);
+
+// src/modules/protocol-model/fields/BlockNumber.ts
+import { AsObjectFactory as AsObjectFactory22 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema22,
   isPayloadOfSchemaType as isPayloadOfSchemaType6,
   isPayloadOfSchemaTypeWithSources
 } from "@xyo-network/sdk";
-var BlockNumberSchema = asSchema19("network.xyo.chain.block.number", true);
+var BlockNumberSchema = asSchema22("network.xyo.chain.block.number", true);
 var isBlockNumberPayload = isPayloadOfSchemaType6(BlockNumberSchema);
-var asBlockNumberPayload = AsObjectFactory19.create(isBlockNumberPayload);
+var asBlockNumberPayload = AsObjectFactory22.create(isBlockNumberPayload);
 var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
-var asBlockNumberPayloadWithSources = AsObjectFactory19.create(isBlockNumberPayloadWithSources);
+var asBlockNumberPayloadWithSources = AsObjectFactory22.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 z39 } from "zod/mini";
+import { z as z43 } from "zod/mini";
 
 // src/modules/protocol-model/model/ChainQualification.ts
-import { HashZod as HashZod7, zodIsFactory as zodIsFactory13 } from "@ariestools/sdk";
-import { z as z38 } from "zod";
+import { HashZod as HashZod10, zodIsFactory as zodIsFactory13 } from "@ariestools/sdk";
+import { z as z42 } from "zod";
 
 // src/modules/protocol-model/model/BlockRange/BlockRange.ts
 import {
@@ -1075,9 +1160,9 @@ import {
   zodAsFactory as zodAsFactory13,
   zodToFactory as zodToFactory13
 } from "@ariestools/sdk";
-import { z as z34 } from "zod";
-var BlockRangeZod = z34.tuple([BlockNumberZod, BlockNumberZod]);
-var BlockRangeishZod = z34.tuple([BlockNumberishZod, BlockNumberishZod]);
+import { z as z38 } from "zod";
+var BlockRangeZod = z38.tuple([BlockNumberZod, BlockNumberZod]);
+var BlockRangeishZod = z38.tuple([BlockNumberishZod, BlockNumberishZod]);
 var asBlockRange = zodAsFactory13(BlockRangeZod, "BlockRange");
 var toBlockRange = zodToFactory13(BlockRangeishZod, "BlockRange");
 var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1094,9 +1179,9 @@ import {
   zodAsFactory as zodAsFactory14,
   zodToFactory as zodToFactory14
 } from "@ariestools/sdk";
-import { z as z35 } from "zod";
-var EthBlockRangeZod = z35.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-var EthBlockRangeishZod = z35.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
+import { z as z39 } from "zod";
+var EthBlockRangeZod = z39.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var EthBlockRangeishZod = z39.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
 var asEthBlockRange = zodAsFactory14(EthBlockRangeZod, "EthBlockRange");
 var toEthBlockRange = zodToFactory14(EthBlockRangeishZod, "EthBlockRange");
 var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1112,8 +1197,8 @@ import {
   zodIsFactory as zodIsFactory12,
   zodToFactory as zodToFactory15
 } from "@ariestools/sdk";
-import { z as z36 } from "zod";
-var RangeZod = z36.tuple([z36.number(), z36.number()]);
+import { z as z40 } from "zod";
+var RangeZod = z40.tuple([z40.number(), z40.number()]);
 var isRange = zodIsFactory12(RangeZod);
 var asRange = zodAsFactory15(RangeZod, "Range");
 var toRange = zodToFactory15(RangeZod, "Range");
@@ -1125,9 +1210,9 @@ import {
   zodAsFactory as zodAsFactory16,
   zodToFactory as zodToFactory16
 } from "@ariestools/sdk";
-import { z as z37 } from "zod";
-var XL1BlockRangeZod = z37.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-var XL1BlockRangeishZod = z37.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
+import { z as z41 } from "zod";
+var XL1BlockRangeZod = z41.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var XL1BlockRangeishZod = z41.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
 var asXL1BlockRange = zodAsFactory16(XL1BlockRangeZod, "XL1BlockRange");
 var toXL1BlockRange = zodToFactory16(XL1BlockRangeishZod, "XL1BlockRange");
 var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1138,29 +1223,29 @@ function fromXL1BlockNumberKey(key, assert) {
 }
 
 // src/modules/protocol-model/model/ChainQualification.ts
-var ChainQualificationZod = z38.object({ head: HashZod7, range: XL1BlockRangeZod });
+var ChainQualificationZod = z42.object({ head: HashZod10, range: XL1BlockRangeZod });
 var isChainQualification = zodIsFactory13(ChainQualificationZod);
-var ChainQualifiedRangeConfigZod = z38.object({ range: XL1BlockRangeZod });
+var ChainQualifiedRangeConfigZod = z42.object({ range: XL1BlockRangeZod });
 var isChainQualifiedRangeConfig = zodIsFactory13(ChainQualifiedRangeConfigZod);
-var ChainQualifiedHeadConfigZod = z38.object({ head: HashZod7 });
+var ChainQualifiedHeadConfigZod = z42.object({ head: HashZod10 });
 var isChainQualifiedHeadConfig = zodIsFactory13(ChainQualifiedHeadConfigZod);
-var ChainQualifiedConfigZod = z38.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z38.object({})]);
+var ChainQualifiedConfigZod = z42.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z42.object({})]);
 var isChainQualifiedConfig = zodIsFactory13(ChainQualifiedConfigZod);
 var ExtendChainQualifiedConfigZod = ((zodType) => {
-  return z38.union([
+  return z42.union([
     ChainQualifiedRangeConfigZod.extend(zodType),
     ChainQualifiedHeadConfigZod.extend(zodType),
     zodType
   ]);
 });
 var ChainQualifiedZod = (zodType) => {
-  return z38.tuple([zodType, ChainQualificationZod]);
+  return z42.tuple([zodType, ChainQualificationZod]);
 };
 
 // src/modules/protocol-model/model/AccountBalance.ts
-var AccountBalanceHistoryItemZod = z39.tuple([
+var AccountBalanceHistoryItemZod = z43.tuple([
   WithHashMetaZod5(BlockBoundWitnessZod),
-  z39.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
+  z43.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
   WithHashMetaZod5(TransferZod)
 ]);
 var AccountBalanceConfigZod = ChainQualifiedConfigZod;
@@ -1179,51 +1264,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 z40 } from "zod";
+import { z as z44 } from "zod";
 function base64Encode(u8) {
   return u8.toBase64();
 }
 function base64Decode(b64) {
   return Uint8Array.fromBase64(b64);
 }
-var ArrayBufferToJsonZod = z40.instanceof(ArrayBuffer).transform((x) => {
+var ArrayBufferToJsonZod = z44.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
 });
-var JsonToArrayBufferZod = z40.string().transform((x) => {
+var JsonToArrayBufferZod = z44.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 z41 } from "zod";
-var TimeDurationsZod = z41.object({
-  millis: z41.number().nonnegative(),
-  seconds: z41.number().nonnegative(),
-  minutes: z41.number().nonnegative(),
-  hours: z41.number().nonnegative(),
-  days: z41.number().nonnegative(),
-  weeks: z41.number().nonnegative()
+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()
 });
 var isTimeDurations = zodIsFactory15(TimeDurationsZod);
 var asTimeDurations = zodAsFactory17(TimeDurationsZod, "asTimeDurations");
 var toTimeDurations = zodAsFactory17(TimeDurationsZod, "toTimeDurations");
-var BlockRateZod = z41.object({
+var BlockRateZod = z45.object({
   range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
-  rate: z41.number().nonnegative().describe("rate of blocks per specified time unit"),
+  rate: z45.number().nonnegative().describe("rate of blocks per specified time unit"),
   timeUnit: TimeDurationsZod.keyof().describe("the unit of time for the rate and timePerBlock"),
-  span: z41.int().nonnegative().describe("number of blocks the rate was calculated over"),
-  timeDifference: z41.number().nonnegative().describe("time difference from start and end block"),
-  timePerBlock: z41.number().nonnegative().describe("average time per block for the given range")
+  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")
 });
 var isBlockRate = zodIsFactory15(BlockRateZod);
 var asBlockRate = zodAsFactory17(BlockRateZod, "asBlockRate");
 var toBlockRate = zodAsFactory17(BlockRateZod, "toBlockRate");
-var CountZod = z41.int().nonnegative().describe("A non-negative integer count");
-var StepIndexZod = z41.int().min(0).max(StepSizes.length - 1).describe("A non-negative integer step index");
-var timeUnitSchema = z41.number().positive();
-var TimeConfigZod = z41.object({
+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({
   minutes: timeUnitSchema.optional(),
   hours: timeUnitSchema.optional(),
   days: timeUnitSchema.optional(),
@@ -1234,30 +1319,30 @@ var TimeConfigZod = z41.object({
 var isTimeConfig = zodIsFactory15(TimeConfigZod);
 var asTimeConfig = zodAsFactory17(TimeConfigZod, "asTimeConfig");
 var toTimeConfig = zodAsFactory17(TimeConfigZod, "toTimeConfig");
-var SingleTimeConfigZod = z41.union([
-  z41.object({ minutes: timeUnitSchema }),
-  z41.object({ hours: timeUnitSchema }),
-  z41.object({ days: timeUnitSchema }),
-  z41.object({ weeks: timeUnitSchema }),
-  z41.object({ months: timeUnitSchema }),
-  z41.object({ years: timeUnitSchema })
+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 })
 ]).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 z42 } from "zod";
-var CachesZod = z42.record(
-  z42.string(),
-  z42.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
+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))
 );
-var SingletonsZod = z42.record(z42.union([z42.string(), z42.symbol()]), z42.unknown());
-var LoggerZod = z42.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
-var MeterProviderZod = z42.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
-var TracerProviderZod = z42.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
-var TimeBudgetLimitZod = z42.number();
-var BaseContextZod = z42.object({
+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({
   caches: CachesZod.optional(),
   logger: LoggerZod.optional(),
   meterProvider: MeterProviderZod.optional(),
@@ -1267,24 +1352,24 @@ var BaseContextZod = z42.object({
 });
 
 // src/modules/protocol-model/model/Context/BlockContext.zod.ts
-import z43 from "zod";
+import z47 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: z43.custom((val) => val != null && typeof val === "object" && "get" in val) }
+  { chainMap: z47.custom((val) => val != null && typeof val === "object" && "get" in val) }
 );
 var BlockContextWriteZod = CachingContextZod.extend(
-  { chainMap: z43.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
+  { chainMap: z47.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 z44 from "zod";
-var HeadContextBaseZod = z44.object(
+import z48 from "zod";
+var HeadContextBaseZod = z48.object(
   { head: WithHashMetaZod6(BlockBoundWitnessZod) }
 );
 var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
@@ -1329,45 +1414,45 @@ import {
   WithHashMetaZod as WithHashMetaZod7,
   WithStorageMetaZod as WithStorageMetaZod5
 } from "@xyo-network/sdk";
-import { z as z45 } from "zod/mini";
-var HydratedTransactionZod = z45.tuple([
+import { z as z49 } from "zod/mini";
+var HydratedTransactionZod = z49.tuple([
   TransactionBoundWitnessZod,
-  z45.array(PayloadZodLoose2)
+  z49.array(PayloadZodLoose2)
 ]);
 var isHydratedTransaction = zodIsFactory16(HydratedTransactionZod);
 var asHydratedTransaction = zodAsFactory18(HydratedTransactionZod, "asHydratedTransaction");
 var toHydratedTransaction = zodToFactory17(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z45.tuple([
+var HydratedTransactionWithHashMetaZod = z49.tuple([
   WithHashMetaZod7(TransactionBoundWitnessZod),
-  z45.array(z45.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z49.array(z49.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isHydratedTransactionWithHashMeta = zodIsFactory16(HydratedTransactionWithHashMetaZod);
 var asHydratedTransactionWithHashMeta = zodAsFactory18(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
 var toHydratedTransactionWithHashMeta = zodToFactory17(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z45.tuple([
+var HydratedTransactionWithStorageMetaZod = z49.tuple([
   WithStorageMetaZod5(TransactionBoundWitnessZod),
-  z45.array(z45.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z49.array(z49.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isHydratedTransactionWithStorageMeta = zodIsFactory16(HydratedTransactionWithStorageMetaZod);
 var asHydratedTransactionWithStorageMeta = zodAsFactory18(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
 var toHydratedTransactionWithStorageMeta = zodToFactory17(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z45.tuple([
+var UnsignedHydratedTransactionZod = z49.tuple([
   UnsignedTransactionBoundWitnessZod,
-  z45.array(PayloadZodLoose2)
+  z49.array(PayloadZodLoose2)
 ]);
 var isUnsignedHydratedTransaction = zodIsFactory16(UnsignedHydratedTransactionZod);
 var asUnsignedHydratedTransaction = zodAsFactory18(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
 var toUnsignedHydratedTransaction = zodToFactory17(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z45.tuple([
+var UnsignedHydratedTransactionWithHashMetaZod = z49.tuple([
   WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
-  z45.array(z45.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z49.array(z49.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory16(UnsignedHydratedTransactionWithHashMetaZod);
 var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory18(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
 var toUnsignedHydratedTransactionWithHashMeta = zodToFactory17(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z45.tuple([
+var UnsignedHydratedTransactionWithStorageMetaZod = z49.tuple([
   WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
-  z45.array(z45.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z49.array(z49.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory16(UnsignedHydratedTransactionWithStorageMetaZod);
 var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory18(
@@ -1378,23 +1463,23 @@ var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory17(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z45.tuple([
+var SignedHydratedTransactionZod = z49.tuple([
   SignedTransactionBoundWitnessZod,
-  z45.array(PayloadZodLoose2)
+  z49.array(PayloadZodLoose2)
 ]);
 var isSignedHydratedTransaction = zodIsFactory16(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory18(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var toSignedHydratedTransaction = zodToFactory17(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z45.tuple([
+var SignedHydratedTransactionWithHashMetaZod = z49.tuple([
   WithHashMetaZod7(SignedTransactionBoundWitnessZod),
-  z45.array(z45.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z49.array(z49.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isSignedHydratedTransactionWithHashMeta = zodIsFactory16(SignedHydratedTransactionWithHashMetaZod);
 var asSignedHydratedTransactionWithHashMeta = zodAsFactory18(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
 var toSignedHydratedTransactionWithHashMeta = zodToFactory17(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z45.tuple([
+var SignedHydratedTransactionWithStorageMetaZod = z49.tuple([
   WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
-  z45.array(z45.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z49.array(z49.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isSignedHydratedTransactionWithStorageMeta = zodIsFactory16(SignedHydratedTransactionWithStorageMetaZod);
 var asSignedHydratedTransactionWithStorageMeta = zodAsFactory18(
@@ -1410,22 +1495,22 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory17(
 var ELEVATE_OPCODE = "elevate";
 
 // src/modules/protocol-model/model/Permission.ts
-import { z as z46 } from "zod";
-var CaveatTypesZod = z46.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z46.object({
+import { z as z50 } from "zod";
+var CaveatTypesZod = z50.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z50.object({
   type: CaveatTypesZod,
-  value: z46.json()
+  value: z50.json()
 });
-var PermissionZod = z46.object({
-  parentCapability: z46.string(),
+var PermissionZod = z50.object({
+  parentCapability: z50.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z46.string()
+  invoker: z50.string()
 });
-var InvokerPermissionZod = PermissionZod.safeExtend({ date: z46.number().optional() });
-var PermissionRequestZod = z46.record(z46.string(), z46.record(z46.string(), z46.any()));
-var RequestedPermissionZod = z46.object({
-  parentCapability: z46.string(),
-  date: z46.number().optional()
+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()
 });
 
 // src/modules/protocol-model/model/rewards.ts
@@ -1439,54 +1524,54 @@ 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 XyoAddressZod7 } from "@xyo-network/sdk";
-import { z as z47 } from "zod";
-var RewardsRangeOptionsZod = z47.object({
-  positions: z47.array(z47.number()).optional(),
+import { XyoAddressZod as XyoAddressZod10 } from "@xyo-network/sdk";
+import { z as z51 } from "zod";
+var RewardsRangeOptionsZod = z51.object({
+  positions: z51.array(z51.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z47.array(StepIdentityZod).optional(),
-  stakers: z47.array(XyoAddressZod7).optional()
+  steps: z51.array(StepIdentityZod).optional(),
+  stakers: z51.array(XyoAddressZod10).optional()
 });
 
 // src/modules/protocol-model/model/Sequence.ts
 import { HexRegExMinMax, toHex } from "@ariestools/sdk";
 import { SequenceConstants } from "@xyo-network/sdk";
-import { z as z48 } from "zod";
+import { z as z52 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z48.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z48.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z52.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z52.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z48.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z48.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z48.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z48.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+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]);
 
 // src/modules/protocol-model/model/Stake.ts
 import { HexZod as HexZod7 } from "@ariestools/sdk";
-import { XyoAddressZod as XyoAddressZod8 } from "@xyo-network/sdk";
-import { z as z49 } from "zod";
-var StakeZod = z49.object({
+import { XyoAddressZod as XyoAddressZod11 } from "@xyo-network/sdk";
+import { z as z53 } from "zod";
+var StakeZod = z53.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z49.number(),
+  addBlock: z53.number(),
   // the unique id for the stake item
-  id: z49.number(),
+  id: z53.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z49.number(),
+  removeBlock: z53.number(),
   // the address that is being staked
-  staked: XyoAddressZod8,
+  staked: XyoAddressZod11,
   // the address that owns the stake
-  staker: XyoAddressZod8,
+  staker: XyoAddressZod11,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z49.number()
+  withdrawBlock: z53.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
   amount: BigIntToJsonZod2.parse(val.amount),
   id: val.id,
   removeBlock: val.removeBlock,
-  staked: XyoAddressZod8.parse(val.staked),
-  staker: XyoAddressZod8.parse(val.staker),
+  staked: XyoAddressZod11.parse(val.staked),
+  staker: XyoAddressZod11.parse(val.staker),
   withdrawBlock: val.withdrawBlock
 }));
 var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
@@ -1505,73 +1590,73 @@ import {
   zodIsFactory as zodIsFactory17,
   zodToFactory as zodToFactory18
 } from "@ariestools/sdk";
-import { z as z50 } from "zod";
-var SyncStepSummaryMetadataZod = z50.object({
+import { z as z54 } from "zod";
+var SyncStepSummaryMetadataZod = z54.object({
   block: XL1BlockNumberZod,
-  blockCount: z50.int().nonnegative(),
-  bytes: z50.int().nonnegative(),
-  createdAt: z50.string(),
+  blockCount: z54.int().nonnegative(),
+  bytes: z54.int().nonnegative(),
+  createdAt: z54.string(),
   endBlock: XL1BlockNumberZod,
-  relativePath: z50.string(),
+  relativePath: z54.string(),
   startBlock: XL1BlockNumberZod,
-  step: z50.int().nonnegative(),
+  step: z54.int().nonnegative(),
   stepSize: XL1BlockNumberZod,
-  updatedAt: z50.string()
+  updatedAt: z54.string()
 });
 var isSyncStepSummaryMetadata = zodIsFactory17(SyncStepSummaryMetadataZod);
 var asSyncStepSummaryMetadata = zodAsFactory19(SyncStepSummaryMetadataZod, "asSyncStepSummaryMetadata");
 var toSyncStepSummaryMetadata = zodToFactory18(SyncStepSummaryMetadataZod, "toSyncStepSummaryMetadata");
-var SyncStepSummaryStatusZod = z50.object({
-  currentBlock: z50.optional(XL1BlockNumberZod),
-  isIndexing: z50.boolean(),
-  nextBoundaries: z50.record(z50.string(), XL1BlockNumberZod),
-  summaries: z50.array(SyncStepSummaryMetadataZod),
-  summaryCount: z50.int().nonnegative()
+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 isSyncStepSummaryStatus = zodIsFactory17(SyncStepSummaryStatusZod);
 var asSyncStepSummaryStatus = zodAsFactory19(SyncStepSummaryStatusZod, "asSyncStepSummaryStatus");
 var toSyncStepSummaryStatus = zodToFactory18(SyncStepSummaryStatusZod, "toSyncStepSummaryStatus");
-var SyncStepSummaryZod = z50.array(SignedHydratedBlockWithHashMetaZod);
+var SyncStepSummaryZod = z54.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 z51 } from "zod";
-var TimeDomainZod = z51.union([
-  z51.literal("xl1"),
-  z51.literal("epoch"),
-  z51.literal("ethereum")
+import { z as z55 } from "zod";
+var TimeDomainZod = z55.union([
+  z55.literal("xl1"),
+  z55.literal("epoch"),
+  z55.literal("ethereum")
 ]);
 
 // src/modules/protocol-model/model/TransactionInclusion.ts
 import {
-  HashZod as HashZod8,
+  HashZod as HashZod11,
   zodAsFactory as zodAsFactory20,
   zodIsFactory as zodIsFactory18,
   zodToFactory as zodToFactory19
 } from "@ariestools/sdk";
-import { z as z52 } from "zod";
-var TransactionInclusionZod = z52.object({
+import { z as z56 } from "zod";
+var TransactionInclusionZod = z56.object({
   /** Hash of the finalized block containing the transaction. */
-  blockHash: HashZod8,
+  blockHash: HashZod11,
   /** Number of the finalized block containing the transaction. */
   blockNumber: XL1BlockNumberZod,
   /** Hash of the included transaction. */
-  transactionHash: HashZod8,
+  transactionHash: HashZod11,
   /** Zero-based transaction position within the block. */
-  transactionIndex: z52.int().nonnegative()
+  transactionIndex: z56.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 XyoAddressZod9 } from "@xyo-network/sdk";
-import { z as z53 } from "zod";
-var TransferPairZod = z53.tuple([
-  XyoAddressZod9,
-  XyoAddressZod9
+import { XyoAddressZod as XyoAddressZod12 } from "@xyo-network/sdk";
+import { z as z57 } from "zod";
+var TransferPairZod = z57.tuple([
+  XyoAddressZod12,
+  XyoAddressZod12
 ]);
 
 // src/modules/protocol-model/model/version.ts
@@ -1590,57 +1675,57 @@ var asProviderMoniker = (value) => {
 var DefaultProviderMoniker = "Provider";
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory20 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory23 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema20,
+  asSchema as asSchema23,
   isPayloadOfSchemaType as isPayloadOfSchemaType7,
   PayloadZodOfSchema as PayloadZodOfSchema3
 } from "@xyo-network/sdk";
-import { z as z55 } from "zod/mini";
+import { z as z59 } from "zod/mini";
 
 // src/modules/protocol-model/rejection/RejectionError.ts
-import { HashZod as HashZod9 } from "@ariestools/sdk";
-import { z as z54 } from "zod";
-var RejectionErrorZod = z54.object({
-  hash: HashZod9,
-  message: z54.string().optional(),
-  name: z54.string()
+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()
 }).loose();
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-var BlockRejectionSchema = asSchema20("network.xyo.block.rejection", true);
-var BlockRejectionFieldsZod = z55.object({
+var BlockRejectionSchema = asSchema23("network.xyo.block.rejection", true);
+var BlockRejectionFieldsZod = z59.object({
   block: HydratedBlockZod,
-  errors: z55.array(RejectionErrorZod),
-  rejector: z55.string()
+  errors: z59.array(RejectionErrorZod),
+  rejector: z59.string()
 });
-var BlockRejectionZod = z55.extend(
+var BlockRejectionZod = z59.extend(
   PayloadZodOfSchema3(BlockRejectionSchema),
   BlockRejectionFieldsZod.shape
 );
 var isBlockRejection = isPayloadOfSchemaType7(BlockRejectionSchema);
-var asBlockRejection = AsObjectFactory20.create(isBlockRejection);
+var asBlockRejection = AsObjectFactory23.create(isBlockRejection);
 
 // src/modules/protocol-model/rejection/TransactionRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory21 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory24 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema21,
+  asSchema as asSchema24,
   isPayloadOfSchemaType as isPayloadOfSchemaType8,
   PayloadZodOfSchema as PayloadZodOfSchema4
 } from "@xyo-network/sdk";
-import { z as z56 } from "zod/mini";
-var TransactionRejectionSchema = asSchema21("network.xyo.transaction.rejection", true);
-var TransactionRejectionFieldsZod = z56.object({
-  errors: z56.array(RejectionErrorZod),
-  rejector: z56.string(),
+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(),
   transaction: HydratedTransactionZod
 });
-var TransactionRejectionZod = z56.extend(
+var TransactionRejectionZod = z60.extend(
   PayloadZodOfSchema4(TransactionRejectionSchema),
   TransactionRejectionFieldsZod.shape
 );
 var isTransactionRejection = isPayloadOfSchemaType8(TransactionRejectionSchema);
-var asTransactionRejection = AsObjectFactory21.create(isTransactionRejection);
+var asTransactionRejection = AsObjectFactory24.create(isTransactionRejection);
 export {
   AccountBalanceConfigZod,
   AccountBalanceHistoryItemZod,
@@ -1687,6 +1772,10 @@ export {
   BridgeSourceObservationSchema,
   CachesZod,
   CachingContextZod,
+  CandidatePairFieldsZod,
+  CandidatePairSchema,
+  CandidateSeenFieldsZod,
+  CandidateSeenSchema,
   CaveatTypesZod,
   CaveatsZod,
   ChainContextReadZod,
@@ -1710,6 +1799,10 @@ export {
   EthBlockRangeZod,
   EthBlockRangeishZod,
   EthereumTimeFieldsZod,
+  EvidenceDispositionZod,
+  EvidenceDispositions,
+  EvidenceNoteFieldsZod,
+  EvidenceNoteSchema,
   ExchangeOutcomeFieldsZod,
   ExchangeOutcomeSchema,
   ExchangeTermsFieldsZod,
@@ -1877,10 +1970,13 @@ export {
   asBridgeDestinationObservation,
   asBridgeIntent,
   asBridgeSourceObservation,
+  asCandidatePair,
+  asCandidateSeen,
   asChainId,
   asChainStakeIntent,
   asEthBlockNumber,
   asEthBlockRange,
+  asEvidenceNote,
   asExchangeOutcome,
   asExchangeTerms,
   asExecutable,
@@ -1971,6 +2067,8 @@ export {
   isBridgeDestinationObservation,
   isBridgeIntent,
   isBridgeSourceObservation,
+  isCandidatePair,
+  isCandidateSeen,
   isChainId,
   isChainQualification,
   isChainQualifiedConfig,
@@ -1978,6 +2076,7 @@ export {
   isChainQualifiedRangeConfig,
   isChainStakeIntent,
   isChainStakeIntentWithStorageMeta,
+  isEvidenceNote,
   isExchangeOutcome,
   isExchangeTerms,
   isExecutable,