@xyo-network/xl1-protocol 5.3.8 → 5.4.1

package/dist/neutral/protocol-model.mjs

@@ -1,23 +1,31 @@
 // src/modules/protocol-model/block/AllowedBlockPayload.ts
-import { zodIsFactory as zodIsFactory6 } from "@ariestools/sdk";
+import { zodIsFactory as zodIsFactory7 } from "@ariestools/sdk";
 import {
   BoundWitnessSchema,
   isHashMeta,
   isSchemaPayload,
   SchemaSchema
 } from "@xyo-network/sdk";
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
+
+// src/modules/protocol-model/model/PayloadVersion.ts
+import { zodIsFactory } from "@ariestools/sdk";
+import { z } from "zod/mini";
+var Xl1PayloadVersion = 1e6;
+var Xl1PayloadVersionZod = z.literal(Xl1PayloadVersion);
+var Xl1PayloadVersionFieldsZod = z.object({ $version: z.optional(Xl1PayloadVersionZod) });
+var isXl1PayloadVersionSupported = zodIsFactory(Xl1PayloadVersionFieldsZod);
 
 // src/modules/protocol-model/payload/application/Exchange/ExchangeOutcome.ts
 import { AsObjectFactory, HashZod } from "@ariestools/sdk";
 import { asSchema, isPayloadOfZodType } from "@xyo-network/sdk";
-import { z } from "zod/mini";
+import { z as z2 } from "zod/mini";
 var ExchangeOutcomeSchema = asSchema("network.xyo.exchange.outcome", true);
-var ExchangeOutcomeFieldsZod = z.object({
+var ExchangeOutcomeFieldsZod = z2.object({
   /** Hash of the ExchangeTerms payload this outcome settles */
   terms: HashZod,
   /** Settlement result */
-  outcome: z.enum(["fulfilled", "rejected"])
+  outcome: z2.enum(["fulfilled", "rejected"])
 });
 var isExchangeOutcome = isPayloadOfZodType(
   ExchangeOutcomeFieldsZod,
@@ -32,12 +40,12 @@ import {
   isPayloadOfZodType as isPayloadOfZodType2,
   XyoAddressZod as XyoAddressZod2
 } from "@xyo-network/sdk";
-import { z as z10 } from "zod/mini";
+import { z as z11 } from "zod/mini";
 
 // src/modules/protocol-model/transaction/TransactionBoundWitness.ts
 import {
   zodAsFactory as zodAsFactory6,
-  zodIsFactory as zodIsFactory3,
+  zodIsFactory as zodIsFactory4,
   zodToFactory as zodToFactory6
 } from "@ariestools/sdk";
 import {
@@ -50,18 +58,18 @@ import {
   WithStorageMetaZod,
   XyoAddressZod
 } from "@xyo-network/sdk";
-import { z as z9 } from "zod/mini";
+import { z as z10 } from "zod/mini";
 
 // src/modules/protocol-model/BlockNumber/BlockNumber.ts
 import { zodAsFactory, zodToFactory } from "@ariestools/sdk";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/modules/protocol-model/BlockNumber/Numberish.ts
-import { z as z2 } from "zod";
-var NumberishZod = z2.union([z2.number(), z2.string(), z2.bigint()]).transform((v) => typeof v === "bigint" || typeof v === "string" ? Number(v) : v).pipe(z2.number());
+import { z as z3 } from "zod";
+var NumberishZod = z3.union([z3.number(), z3.string(), z3.bigint()]).transform((v) => typeof v === "bigint" || typeof v === "string" ? Number(v) : v).pipe(z3.number());
 
 // src/modules/protocol-model/BlockNumber/BlockNumber.ts
-var BlockNumberZod = z3.int().nonnegative().transform((v) => v);
+var BlockNumberZod = z4.int().nonnegative().transform((v) => v);
 var BlockNumberishZod = NumberishZod.transform((v) => v);
 var asBlockNumber = zodAsFactory(BlockNumberZod, "asBlockNumber");
 var toBlockNumber = zodToFactory(BlockNumberishZod, "toBlockNumber");
@@ -69,8 +77,8 @@ var BLOCK_NUMBER_ZERO = asBlockNumber(0);
 
 // src/modules/protocol-model/BlockNumber/EthBlockNumber.ts
 import { zodAsFactory as zodAsFactory2, zodToFactory as zodToFactory2 } from "@ariestools/sdk";
-import { z as z4 } from "zod";
-var EthBlockNumberZod = z4.int().nonnegative().transform((v) => v);
+import { z as z5 } from "zod";
+var EthBlockNumberZod = z5.int().nonnegative().transform((v) => v);
 var EthBlockNumberishZod = BlockNumberishZod.transform((v) => v);
 var asEthBlockNumber = zodAsFactory2(EthBlockNumberZod, "asEthBlockNumber");
 var toEthBlockNumber = zodToFactory2(EthBlockNumberishZod, "toEthBlockNumber");
@@ -78,8 +86,8 @@ var ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0);
 
 // src/modules/protocol-model/BlockNumber/xl1BlockNumber.ts
 import { zodAsFactory as zodAsFactory3, zodToFactory as zodToFactory3 } from "@ariestools/sdk";
-import { z as z5 } from "zod";
-var XL1BlockNumberZod = z5.int().nonnegative().transform((v) => v);
+import { z as z6 } from "zod";
+var XL1BlockNumberZod = z6.int().nonnegative().transform((v) => v);
 var XL1BlockNumberishZod = BlockNumberishZod.transform((v) => v);
 var asXL1BlockNumber = zodAsFactory3(XL1BlockNumberZod, "asXL1BlockNumber");
 var toXL1BlockNumber = zodToFactory3(XL1BlockNumberishZod, "toXL1BlockNumber");
@@ -87,18 +95,18 @@ var XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0);
 
 // src/modules/protocol-model/chain/Chain.ts
 import { AddressRegEx, toAddress } from "@ariestools/sdk";
-import { z as z6 } from "zod";
-var ChainZod = z6.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
+import { z as z7 } from "zod";
+var ChainZod = z7.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
 // src/modules/protocol-model/chain/ChainId.ts
 import {
   HexZod,
   zodAsFactory as zodAsFactory4,
-  zodIsFactory,
+  zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory4
 } from "@ariestools/sdk";
 var ChainIdZod = HexZod;
-var isChainId = zodIsFactory(ChainIdZod);
+var isChainId = zodIsFactory2(ChainIdZod);
 var asChainId = zodAsFactory4(ChainIdZod, "asChainId");
 var toChainId = zodToFactory4(ChainIdZod, "toChainId");
 
@@ -108,13 +116,13 @@ import {
   HexZod as HexZod2,
   JsonToBigIntZod,
   zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory2,
+  zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory5
 } from "@ariestools/sdk";
-import { z as z8 } from "zod/mini";
+import { z as z9 } from "zod/mini";
 
 // src/modules/protocol-model/xl1/isXl1Factory.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/modules/protocol-model/xl1/xl1MaxValue.ts
 var xl1MaxValue = (places) => 10n ** (32n - places) - 1n;
@@ -127,7 +135,7 @@ var isXL1Factory = (places) => (val) => {
 var XL1ZodFactory = (places, name) => {
   const is = isXL1Factory(places);
   const message = `Invalid value for ${name}, must be between 0 and ${xl1MaxValue(places)}`;
-  return z7.bigint().refine(
+  return z8.bigint().refine(
     (x) => {
       const result = is(x);
       return result;
@@ -138,7 +146,7 @@ var XL1ZodFactory = (places, name) => {
 var XL1TransformZodFactory = (places, name) => {
   const is = isXL1Factory(places);
   const message = `Invalid value for ${name}, must be between 0 and ${xl1MaxValue(places)}`;
-  return z7.union([z7.bigint(), z7.number(), z7.string(), z7.boolean()]).transform((val) => BigInt(val)).refine(
+  return z8.union([z8.bigint(), z8.number(), z8.string(), z8.boolean()]).transform((val) => BigInt(val)).refine(
     (x) => {
       const result = is(x);
       return result;
@@ -235,38 +243,38 @@ var XL1 = asXL1;
 
 // src/modules/protocol-model/transaction/TransactionFees.ts
 import { BigIntToJsonZod as BigIntToJsonZod2 } from "@ariestools/sdk";
-var AttoZod = z8.bigint();
-var JsonToAttoZod = z8.pipe(JsonToBigIntZod, z8.transform((v) => asAttoXL1(v)));
-var TransactionFeesHexZod = z8.object({
+var AttoZod = z9.bigint();
+var JsonToAttoZod = z9.pipe(JsonToBigIntZod, z9.transform((v) => asAttoXL1(v)));
+var TransactionFeesHexZod = z9.object({
   base: HexZod2,
   gasLimit: HexZod2,
   gasPrice: HexZod2,
   priority: HexZod2
 });
-var isTransactionFeesHex = zodIsFactory2(TransactionFeesHexZod);
+var isTransactionFeesHex = zodIsFactory3(TransactionFeesHexZod);
 var asTransactionFeesHex = zodAsFactory5(TransactionFeesHexZod, "asTransactionFeesHex");
 var toTransactionFeesHex = zodToFactory5(TransactionFeesHexZod, "toTransactionFeesHex");
-var TransactionFeesBigIntZod = z8.object({
+var TransactionFeesBigIntZod = z9.object({
   base: AttoZod,
   gasLimit: AttoZod,
   gasPrice: AttoZod,
   priority: AttoZod
 });
-var isTransactionFeesBigInt = zodIsFactory2(TransactionFeesBigIntZod);
+var isTransactionFeesBigInt = zodIsFactory3(TransactionFeesBigIntZod);
 var asTransactionFeesBigInt = zodAsFactory5(TransactionFeesBigIntZod, "asTransactionFeesBigInt");
 var toTransactionFeesBigInt = zodToFactory5(TransactionFeesBigIntZod, "toTransactionFeesBigInt");
-var TransactionFeesJsonToBigIntZod = z8.pipe(
+var TransactionFeesJsonToBigIntZod = z9.pipe(
   TransactionFeesHexZod,
-  z8.transform((val) => ({
+  z9.transform((val) => ({
     base: JsonToBigIntZod.parse(val.base),
     gasLimit: JsonToBigIntZod.parse(val.gasLimit),
     gasPrice: JsonToBigIntZod.parse(val.gasPrice),
     priority: JsonToBigIntZod.parse(val.priority)
   }))
 );
-var TransactionFeesBigIntToJsonZod = z8.pipe(
+var TransactionFeesBigIntToJsonZod = z9.pipe(
   TransactionFeesBigIntZod,
-  z8.transform((val) => ({
+  z9.transform((val) => ({
     base: BigIntToJsonZod.parse(val.base),
     gasLimit: BigIntToJsonZod.parse(val.gasLimit),
     gasPrice: BigIntToJsonZod.parse(val.gasPrice),
@@ -275,40 +283,41 @@ var TransactionFeesBigIntToJsonZod = z8.pipe(
 );
 
 // src/modules/protocol-model/transaction/TransactionBoundWitness.ts
-var BlockStartZod = z9.object({ nbf: XL1BlockNumberZod });
-var BlockEndZod = z9.object({ exp: XL1BlockNumberZod });
-var BlockDurationZod = z9.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod });
-var BlockScriptsZod = z9.object({ script: z9.optional(z9.array(z9.string())) });
-var TransactionFeesZod = z9.object({ fees: TransactionFeesHexZod });
-var TransactionBoundWitnessIdentityFields = z9.object({ chain: ChainZod, from: XyoAddressZod });
-var TransactionBoundWitnessFieldsZod = z9.safeExtend(
-  z9.safeExtend(
-    z9.safeExtend(
-      z9.safeExtend(z9.object(), BlockDurationZod.shape),
+var BlockStartZod = z10.object({ nbf: XL1BlockNumberZod });
+var BlockEndZod = z10.object({ exp: XL1BlockNumberZod });
+var BlockDurationZod = z10.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod });
+var BlockScriptsZod = z10.object({ script: z10.optional(z10.array(z10.string())) });
+var TransactionFeesZod = z10.object({ fees: TransactionFeesHexZod });
+var TransactionBoundWitnessIdentityFields = z10.object({ chain: ChainZod, from: XyoAddressZod });
+var TransactionBoundWitnessFieldsZod = z10.safeExtend(
+  z10.safeExtend(
+    z10.safeExtend(
+      z10.safeExtend(z10.object(), BlockDurationZod.shape),
       TransactionFeesZod.shape
     ),
     TransactionBoundWitnessIdentityFields.shape
   ),
   BlockScriptsZod.shape
 );
-var TransactionBoundWitnessZod = z9.safeExtend(BoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
-var isTransactionBoundWitness = zodIsFactory3(TransactionBoundWitnessZod);
+var transactionBoundWitnessShape = { ...TransactionBoundWitnessFieldsZod.shape, ...Xl1PayloadVersionFieldsZod.shape };
+var TransactionBoundWitnessZod = z10.safeExtend(BoundWitnessZod, transactionBoundWitnessShape);
+var isTransactionBoundWitness = zodIsFactory4(TransactionBoundWitnessZod);
 var asTransactionBoundWitness = zodAsFactory6(TransactionBoundWitnessZod, "asTransactionBoundWitness");
 var toTransactionBoundWitness = zodToFactory6(TransactionBoundWitnessZod, "toTransactionBoundWitness");
-var TransactionBoundWitnessWithHashMetaZod = z9.safeExtend(TransactionBoundWitnessZod, HashMetaZod.shape);
-var isTransactionBoundWitnessWithHashMeta = zodIsFactory3(TransactionBoundWitnessWithHashMetaZod);
+var TransactionBoundWitnessWithHashMetaZod = z10.safeExtend(TransactionBoundWitnessZod, HashMetaZod.shape);
+var isTransactionBoundWitnessWithHashMeta = zodIsFactory4(TransactionBoundWitnessWithHashMetaZod);
 var asTransactionBoundWitnessWithHashMeta = zodAsFactory6(TransactionBoundWitnessWithHashMetaZod, "asTransactionBoundWitnessWithHashMeta");
 var toTransactionBoundWitnessWithHashMeta = zodToFactory6(TransactionBoundWitnessWithHashMetaZod, "toTransactionBoundWitnessWithHashMeta");
-var TransactionBoundWitnessWithStorageMetaZod = z9.safeExtend(TransactionBoundWitnessZod, StorageMetaZod.shape);
-var isTransactionBoundWitnessWithStorageMeta = zodIsFactory3(TransactionBoundWitnessWithStorageMetaZod);
+var TransactionBoundWitnessWithStorageMetaZod = z10.safeExtend(TransactionBoundWitnessZod, StorageMetaZod.shape);
+var isTransactionBoundWitnessWithStorageMeta = zodIsFactory4(TransactionBoundWitnessWithStorageMetaZod);
 var asTransactionBoundWitnessWithStorageMeta = zodAsFactory6(TransactionBoundWitnessWithStorageMetaZod, "asTransactionBoundWitnessWithStorageMeta");
 var toTransactionBoundWitnessWithStorageMeta = zodToFactory6(TransactionBoundWitnessWithStorageMetaZod, "toTransactionBoundWitnessWithStorageMeta");
-var UnsignedTransactionBoundWitnessZod = z9.safeExtend(UnsignedBoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
-var isUnsignedTransactionBoundWitness = zodIsFactory3(UnsignedTransactionBoundWitnessZod);
+var UnsignedTransactionBoundWitnessZod = z10.safeExtend(UnsignedBoundWitnessZod, transactionBoundWitnessShape);
+var isUnsignedTransactionBoundWitness = zodIsFactory4(UnsignedTransactionBoundWitnessZod);
 var asUnsignedTransactionBoundWitness = zodAsFactory6(UnsignedTransactionBoundWitnessZod, "asUnsignedTransactionBoundWitness");
 var toUnsignedTransactionBoundWitness = zodToFactory6(UnsignedTransactionBoundWitnessZod, "toUnsignedTransactionBoundWitness");
-var UnsignedTransactionBoundWitnessWithHashMetaZod = z9.safeExtend(UnsignedTransactionBoundWitnessZod, HashMetaZod.shape);
-var isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory3(UnsignedTransactionBoundWitnessWithHashMetaZod);
+var UnsignedTransactionBoundWitnessWithHashMetaZod = z10.safeExtend(UnsignedTransactionBoundWitnessZod, HashMetaZod.shape);
+var isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory4(UnsignedTransactionBoundWitnessWithHashMetaZod);
 var asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory6(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   "asUnsignedTransactionBoundWitnessWithHashMeta"
@@ -317,8 +326,8 @@ var toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory6(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   "toUnsignedTransactionBoundWitnessWithHashMeta"
 );
-var UnsignedTransactionBoundWitnessWithStorageMetaZod = z9.safeExtend(UnsignedTransactionBoundWitnessZod, StorageMetaZod.shape);
-var isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory3(UnsignedTransactionBoundWitnessWithStorageMetaZod);
+var UnsignedTransactionBoundWitnessWithStorageMetaZod = z10.safeExtend(UnsignedTransactionBoundWitnessZod, StorageMetaZod.shape);
+var isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory4(UnsignedTransactionBoundWitnessWithStorageMetaZod);
 var asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory6(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   "asUnsignedTransactionBoundWitnessWithStorageMeta"
@@ -327,12 +336,12 @@ var toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory6(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   "toUnsignedTransactionBoundWitnessWithStorageMeta"
 );
-var SignedTransactionBoundWitnessZod = z9.safeExtend(SignedBoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
-var isSignedTransactionBoundWitness = zodIsFactory3(SignedTransactionBoundWitnessZod);
+var SignedTransactionBoundWitnessZod = z10.safeExtend(SignedBoundWitnessZod, transactionBoundWitnessShape);
+var isSignedTransactionBoundWitness = zodIsFactory4(SignedTransactionBoundWitnessZod);
 var asSignedTransactionBoundWitness = zodAsFactory6(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
 var toSignedTransactionBoundWitness = zodToFactory6(SignedTransactionBoundWitnessZod, "toSignedTransactionBoundWitness");
 var SignedTransactionBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedTransactionBoundWitnessZod);
-var isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory3(SignedTransactionBoundWitnessWithHashMetaZod);
+var isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory4(SignedTransactionBoundWitnessWithHashMetaZod);
 var asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory6(
   SignedTransactionBoundWitnessWithHashMetaZod,
   "asSignedTransactionBoundWitnessWithHashMeta"
@@ -342,7 +351,7 @@ var toSignedTransactionBoundWitnessWithHashMeta = zodToFactory6(
   "toSignedTransactionBoundWitnessWithHashMeta"
 );
 var SignedTransactionBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedTransactionBoundWitnessZod);
-var isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory3(SignedTransactionBoundWitnessWithStorageMetaZod);
+var isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory4(SignedTransactionBoundWitnessWithStorageMetaZod);
 var asSignedTransactionBoundWitnessWithStorageMeta = zodAsFactory6(
   SignedTransactionBoundWitnessWithStorageMetaZod,
   "asSignedTransactionBoundWitnessWithStorageMeta"
@@ -354,23 +363,23 @@ var toSignedTransactionBoundWitnessWithStorageMeta = zodToFactory6(
 
 // src/modules/protocol-model/payload/application/Exchange/ExchangeTerms.ts
 var ExchangeTermsSchema = asSchema2("network.xyo.exchange.terms", true);
-var ExchangeTermsFieldsZod = z10.extend(
-  z10.object({
+var ExchangeTermsFieldsZod = z11.extend(
+  z11.object({
     /** Stable identifier for this exchange */
-    exchangeId: z10.string(),
+    exchangeId: z11.string(),
     /**
      * Each party is a set of addresses (most parties have one wallet; a multi-sig org may have several).
      * All addresses in the set must co-sign the party's secret reveal at settlement.
      */
-    parties: z10.array(z10.array(XyoAddressZod2)).check(z10.minLength(2)),
+    parties: z11.array(z11.array(XyoAddressZod2)).check(z11.minLength(2)),
     /** One hash per party — the data hash of that party's PartySecretReveal payload */
-    partySecrets: z10.array(HashZod2),
+    partySecrets: z11.array(HashZod2),
     /** Hashes of the asset payload(s) being exchanged */
-    assets: z10.array(HashZod2),
+    assets: z11.array(HashZod2),
     /** Optional — addresses whose signature on appraisal payloads is accepted */
-    appraisalAuthorities: z10.optional(z10.array(XyoAddressZod2)),
+    appraisalAuthorities: z11.optional(z11.array(XyoAddressZod2)),
     /** Optional — addresses whose signature on payment-receipt payloads is accepted */
-    paymentAuthorities: z10.optional(z10.array(XyoAddressZod2))
+    paymentAuthorities: z11.optional(z11.array(XyoAddressZod2))
   }),
   BlockDurationZod.shape
 );
@@ -383,11 +392,11 @@ var asExchangeTerms = AsObjectFactory2.create(isExchangeTerms);
 // src/modules/protocol-model/payload/application/Exchange/PartySecretReveal.ts
 import { AsObjectFactory as AsObjectFactory3 } from "@ariestools/sdk";
 import { asSchema as asSchema3, isPayloadOfZodType as isPayloadOfZodType3 } from "@xyo-network/sdk";
-import { z as z11 } from "zod/mini";
+import { z as z12 } from "zod/mini";
 var PartySecretRevealSchema = asSchema3("network.xyo.exchange.party.secret", true);
-var PartySecretRevealFieldsZod = z11.object({
+var PartySecretRevealFieldsZod = z12.object({
   /** Random opaque value — the bytes don't matter; what matters is that the party signed them */
-  nonce: z11.string()
+  nonce: z12.string()
 });
 var isPartySecretReveal = isPayloadOfZodType3(
   PartySecretRevealFieldsZod,
@@ -398,13 +407,13 @@ var asPartySecretReveal = AsObjectFactory3.create(isPartySecretReveal);
 // src/modules/protocol-model/payload/application/Ordinal/Inscription.ts
 import { AsObjectFactory as AsObjectFactory4 } from "@ariestools/sdk";
 import { asSchema as asSchema4, isPayloadOfZodType as isPayloadOfZodType4 } from "@xyo-network/sdk";
-import { z as z12 } from "zod/mini";
+import { z as z13 } from "zod/mini";
 var InscriptionSchema = asSchema4("network.xyo.ordinal.inscription", true);
-var InscriptionFieldsZod = z12.object({
+var InscriptionFieldsZod = z13.object({
   /** MIME type of the inscribed content (e.g. 'text/plain', 'image/png', 'application/json') */
-  contentType: z12.string(),
+  contentType: z13.string(),
   /** Inscribed content — base64 for binary, raw for text/JSON */
-  content: z12.string()
+  content: z13.string()
 });
 var isInscription = isPayloadOfZodType4(InscriptionFieldsZod, InscriptionSchema);
 var asInscription = AsObjectFactory4.create(isInscription);
@@ -416,9 +425,9 @@ import {
   isPayloadOfZodType as isPayloadOfZodType5,
   XyoAddressZod as XyoAddressZod3
 } from "@xyo-network/sdk";
-import { z as z13 } from "zod/mini";
+import { z as z14 } from "zod/mini";
 var OrdinalTransferSchema = asSchema5("network.xyo.ordinal.transfer", true);
-var OrdinalTransferFieldsZod = z13.object({
+var OrdinalTransferFieldsZod = z14.object({
   /** Content-addressed hash of the target inscription payload */
   inscriptionId: HashZod3,
   /** Recipient address — declarative content; the current owner is derived structurally */
@@ -431,19 +440,19 @@ var isOrdinalTransfer = isPayloadOfZodType5(
 var asOrdinalTransfer = AsObjectFactory5.create(isOrdinalTransfer);
 
 // src/modules/protocol-model/payload/application/Xrc20/Ticker.ts
-import { z as z14 } from "zod/mini";
-var TickerZod = z14.string().check(z14.minLength(1), z14.maxLength(8));
+import { z as z15 } from "zod/mini";
+var TickerZod = z15.string().check(z15.minLength(1), z15.maxLength(8));
 
 // src/modules/protocol-model/payload/application/Xrc20/TokenAmount.ts
-import { z as z15 } from "zod/mini";
-var TokenAmountZod = z15.string().check(z15.regex(/^\d+$/));
+import { z as z16 } from "zod/mini";
+var TokenAmountZod = z16.string().check(z16.regex(/^\d+$/));
 
 // src/modules/protocol-model/payload/application/Xrc20/TokenDeploy.ts
 import { AsObjectFactory as AsObjectFactory6 } from "@ariestools/sdk";
 import { asSchema as asSchema6, isPayloadOfZodType as isPayloadOfZodType6 } from "@xyo-network/sdk";
-import { z as z16 } from "zod/mini";
+import { z as z17 } from "zod/mini";
 var TokenDeploySchema = asSchema6("network.xyo.ordinal.token.deploy", true);
-var TokenDeployFieldsZod = z16.object({
+var TokenDeployFieldsZod = z17.object({
   /** Ticker symbol — case-folded by the indexer */
   tick: TickerZod,
   /** Total supply */
@@ -451,7 +460,7 @@ var TokenDeployFieldsZod = z16.object({
   /** Per-mint cap */
   lim: TokenAmountZod,
   /** Optional decimals (0–18); defaults to 0 in the indexer */
-  decimals: z16.optional(z16.int().check(z16.gte(0), z16.lte(18)))
+  decimals: z17.optional(z17.int().check(z17.gte(0), z17.lte(18)))
 });
 var isTokenDeploy = isPayloadOfZodType6(TokenDeployFieldsZod, TokenDeploySchema);
 var asTokenDeploy = AsObjectFactory6.create(isTokenDeploy);
@@ -459,9 +468,9 @@ var asTokenDeploy = AsObjectFactory6.create(isTokenDeploy);
 // src/modules/protocol-model/payload/application/Xrc20/TokenMint.ts
 import { AsObjectFactory as AsObjectFactory7 } from "@ariestools/sdk";
 import { asSchema as asSchema7, isPayloadOfZodType as isPayloadOfZodType7 } from "@xyo-network/sdk";
-import { z as z17 } from "zod/mini";
+import { z as z18 } from "zod/mini";
 var TokenMintSchema = asSchema7("network.xyo.ordinal.token.mint", true);
-var TokenMintFieldsZod = z17.object({
+var TokenMintFieldsZod = z18.object({
   /** Ticker being minted */
   tick: TickerZod,
   /** Amount minted */
@@ -477,9 +486,9 @@ import {
   isPayloadOfZodType as isPayloadOfZodType8,
   XyoAddressZod as XyoAddressZod4
 } from "@xyo-network/sdk";
-import { z as z18 } from "zod/mini";
+import { z as z19 } from "zod/mini";
 var TokenTransferSchema = asSchema8("network.xyo.ordinal.token.transfer", true);
-var TokenTransferFieldsZod = z18.object({
+var TokenTransferFieldsZod = z19.object({
   /** Ticker being transferred */
   tick: TickerZod,
   /** Recipient address — declarative content; the sender is derived structurally */
@@ -496,59 +505,59 @@ var asTokenTransfer = AsObjectFactory8.create(isTokenTransfer);
 // src/modules/protocol-model/payload/elevatable/Bridge/BridgeDestinationObservation.ts
 import { AsObjectFactory as AsObjectFactory9, HexZod as HexZod4 } from "@ariestools/sdk";
 import { asSchema as asSchema9, isPayloadOfZodType as isPayloadOfZodType9 } from "@xyo-network/sdk";
-import { z as z20 } from "zod/mini";
+import { z as z21 } from "zod/mini";
 
 // src/modules/protocol-model/payload/elevatable/Bridge/BridgeDetails.ts
 import { HexZod as HexZod3 } from "@ariestools/sdk";
-import { z as z19 } from "zod/mini";
-var BridgeDetailsDestinationFieldsZod = z19.object({
+import { z as z20 } from "zod/mini";
+var BridgeDetailsDestinationFieldsZod = z20.object({
   /**
    * Destination network
    */
-  dest: HexZod3.check(z19.describe("The destination network identifier")),
+  dest: HexZod3.check(z20.describe("The destination network identifier")),
   /**
    * Destination address (EOA or contract)
    */
-  destAddress: HexZod3.check(z19.describe("The destination address (EOA or contract)")),
+  destAddress: HexZod3.check(z20.describe("The destination address (EOA or contract)")),
   /**
    * Token amount to bridge to destination
    */
-  destAmount: HexZod3.check(z19.describe("The token amount to bridge to destination")),
+  destAmount: HexZod3.check(z20.describe("The token amount to bridge to destination")),
   /**
    * Token being bridged to
    */
-  destToken: HexZod3.check(z19.describe("The token being bridged to"))
+  destToken: HexZod3.check(z20.describe("The token being bridged to"))
 });
-var BridgeDetailsSourceFieldsZod = z19.object({
+var BridgeDetailsSourceFieldsZod = z20.object({
   /**
    * Source network
    */
-  src: HexZod3.check(z19.describe("The source network identifier")),
+  src: HexZod3.check(z20.describe("The source network identifier")),
   /**
    * Source address (EOA or contract)
    */
-  srcAddress: HexZod3.check(z19.describe("The source address (EOA or contract)")),
+  srcAddress: HexZod3.check(z20.describe("The source address (EOA or contract)")),
   /**
    * Token amount to bridge from source
    */
-  srcAmount: HexZod3.check(z19.describe("The token amount to bridge from source")),
+  srcAmount: HexZod3.check(z20.describe("The token amount to bridge from source")),
   /**
    * Token being bridged from
    */
-  srcToken: HexZod3.check(z19.describe("The token being bridged from"))
+  srcToken: HexZod3.check(z20.describe("The token being bridged from"))
 });
-var BridgeDetailsFieldsZod = z19.extend(
+var BridgeDetailsFieldsZod = z20.extend(
   BridgeDetailsSourceFieldsZod,
   BridgeDetailsDestinationFieldsZod.shape
 );
 
 // src/modules/protocol-model/payload/elevatable/Bridge/BridgeDestinationObservation.ts
 var BridgeDestinationObservationSchema = asSchema9("network.xyo.chain.bridge.observation.destination", true);
-var BridgeDestinationObservationFieldsZod = z20.extend(BridgeDetailsFieldsZod, {
+var BridgeDestinationObservationFieldsZod = z21.extend(BridgeDetailsFieldsZod, {
   /**
    * Destination chain confirmation
    */
-  destConfirmation: z20.optional(HexZod4).check(z20.describe("Destination chain confirmation"))
+  destConfirmation: z21.optional(HexZod4).check(z21.describe("Destination chain confirmation"))
 });
 var isBridgeDestinationObservation = isPayloadOfZodType9(
   BridgeDestinationObservationFieldsZod,
@@ -559,13 +568,13 @@ var asBridgeDestinationObservation = AsObjectFactory9.create(isBridgeDestination
 // src/modules/protocol-model/payload/elevatable/Bridge/BridgeIntent.ts
 import { AsObjectFactory as AsObjectFactory10 } from "@ariestools/sdk";
 import { asSchema as asSchema10, isPayloadOfZodType as isPayloadOfZodType10 } from "@xyo-network/sdk";
-import { z as z21 } from "zod/mini";
+import { z as z22 } from "zod/mini";
 var BridgeIntentSchema = asSchema10("network.xyo.chain.bridge.intent", true);
-var BridgeIntentFieldsZod = z21.extend(BridgeDetailsFieldsZod, {
+var BridgeIntentFieldsZod = z22.extend(BridgeDetailsFieldsZod, {
   /**
    * Unique identifier for replay protection
    */
-  nonce: z21.string().check(z21.describe("Unique identifier for replay protection"))
+  nonce: z22.string().check(z22.describe("Unique identifier for replay protection"))
 });
 var isBridgeIntent = isPayloadOfZodType10(
   BridgeIntentFieldsZod,
@@ -576,13 +585,13 @@ var asBridgeIntent = AsObjectFactory10.create(isBridgeIntent);
 // src/modules/protocol-model/payload/elevatable/Bridge/BridgeSourceObservation.ts
 import { AsObjectFactory as AsObjectFactory11, HexZod as HexZod5 } from "@ariestools/sdk";
 import { asSchema as asSchema11, isPayloadOfZodType as isPayloadOfZodType11 } from "@xyo-network/sdk";
-import { z as z22 } from "zod/mini";
+import { z as z23 } from "zod/mini";
 var BridgeSourceObservationSchema = asSchema11("network.xyo.chain.bridge.observation.source", true);
-var BridgeSourceObservationFieldsZod = z22.extend(BridgeDetailsFieldsZod, {
+var BridgeSourceObservationFieldsZod = z23.extend(BridgeDetailsFieldsZod, {
   /**
    * Source chain confirmation
    */
-  srcConfirmation: z22.optional(HexZod5).check(z22.describe("Source chain confirmation"))
+  srcConfirmation: z23.optional(HexZod5).check(z23.describe("Source chain confirmation"))
 });
 var isBridgeSourceObservation = isPayloadOfZodType11(
   BridgeSourceObservationFieldsZod,
@@ -613,7 +622,7 @@ var asNonNegativeInteger = (num) => {
 import {
   AsObjectFactory as AsObjectFactory13,
   HashZod as HashZod4,
-  zodIsFactory as zodIsFactory4
+  zodIsFactory as zodIsFactory5
 } from "@ariestools/sdk";
 import {
   asSchema as asSchema13,
@@ -621,24 +630,38 @@ import {
   PayloadZodOfSchema,
   XyoAddressZod as XyoAddressZod5
 } from "@xyo-network/sdk";
-import { z as z23 } from "zod/mini";
+import { z as z24 } 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(
+var ClaimSubjectZod = z24.union([XyoAddressZod5, HashZod4]);
+var ClaimFieldsZod = z24.object({
+  /** The claims being made about the subject.
+   * These should be from a set of 'known' hashes of which the reducer has a complete set */
+  hashes: z24.array(HashZod4).check(
+    z24.minLength(1),
+    z24.maxLength(MAX_CLAIM_HASHES),
+    z24.refine(
       (hashes) => new Set(hashes).size === hashes.length,
       { error: "duplicate hashes" }
     )
   ),
-  source: XyoAddressZod5
+  /** The address making the claim
+   * We need this since we can not use the tx signer(s) because one may be a signing pool
+  */
+  source: XyoAddressZod5,
+  /** This is the thing that the claim is being made about */
+  subject: ClaimSubjectZod
 });
-var ClaimZod = z23.extend(PayloadZodOfSchema(ClaimSchema), ClaimFieldsZod.shape);
-var isClaim = isPayloadOfSchemaType2(ClaimSchema);
-var isClaimPayload = zodIsFactory4(ClaimZod);
-var asClaim = AsObjectFactory13.create(isClaim);
+var ClaimZod = z24.extend(PayloadZodOfSchema(ClaimSchema), {
+  ...ClaimFieldsZod.shape,
+  ...Xl1PayloadVersionFieldsZod.shape
+});
+var isClaimOfSchema = isPayloadOfSchemaType2(ClaimSchema);
+var isClaim = (value) => {
+  return isXl1PayloadVersionSupported(value) && isClaimOfSchema(value);
+};
+var isClaimPayload = zodIsFactory5(ClaimZod);
+var asClaim = AsObjectFactory13.create(isClaimPayload);
 var asClaimPayload = AsObjectFactory13.create(isClaimPayload);
 
 // src/modules/protocol-model/payload/elevatable/Executable.ts
@@ -675,35 +698,39 @@ import {
   isPayloadOfSchemaType as isPayloadOfSchemaType5,
   PayloadZodOfSchema as PayloadZodOfSchema2
 } from "@xyo-network/sdk";
-import { z as z24 } from "zod/mini";
+import { z as z25 } from "zod/mini";
 var TimeSchema = asSchema16("network.xyo.time", true);
-var XL1TimeFieldsZod = z24.object({
+var XL1TimeFieldsZod = z25.object({
   // block number
-  xl1: z24.optional(z24.number()),
+  xl1: z25.optional(z25.number()),
   // block hash
-  xl1Hash: z24.optional(HashZod5)
+  xl1Hash: z25.optional(HashZod5)
 });
-var EthereumTimeFieldsZod = z24.object({
+var EthereumTimeFieldsZod = z25.object({
   // block number
-  ethereum: z24.optional(z24.number()),
+  ethereum: z25.optional(z25.number()),
   // block hash
-  ethereumHash: z24.optional(HashZod5)
+  ethereumHash: z25.optional(HashZod5)
 });
-var EpochTimeFieldsZod = z24.object({
+var EpochTimeFieldsZod = z25.object({
   // in milliseconds
-  epoch: z24.number()
+  epoch: z25.number()
 });
-var TimeFieldsZod = z24.extend(
-  z24.extend(z24.extend(XL1TimeFieldsZod, XL1TimeFieldsZod.shape), EthereumTimeFieldsZod.shape),
+var TimeFieldsZod = z25.extend(
+  z25.extend(z25.extend(XL1TimeFieldsZod, XL1TimeFieldsZod.shape), EthereumTimeFieldsZod.shape),
   EpochTimeFieldsZod.shape
 );
-var TimePayloadZod = z24.extend(PayloadZodOfSchema2(TimeSchema), TimeFieldsZod.shape);
+var TimePayloadZod = z25.extend(PayloadZodOfSchema2(TimeSchema), {
+  ...TimeFieldsZod.shape,
+  ...Xl1PayloadVersionFieldsZod.shape
+});
+var isTimePayloadOfSchema = isPayloadOfSchemaType5(TimeSchema);
 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 isPayloadOfSchemaType5(TimeSchema)(value) && isSafeEpoch(value.epoch);
+  return isXl1PayloadVersionSupported(value) && isTimePayloadOfSchema(value) && isSafeEpoch(value.epoch);
 };
 var asTimePayload = AsObjectFactory16.create(isTimePayload);
 var asTimePayloadWithStorageMeta = AsObjectFactory16.create(isTimePayload);
@@ -715,21 +742,21 @@ import {
   isPayloadOfZodType as isPayloadOfZodType12,
   XyoAddressZod as XyoAddressZod6
 } from "@xyo-network/sdk";
-import { z as z25 } from "zod/mini";
+import { z as z26 } from "zod/mini";
 var SlashOutcomes = ["confirmed", "refuted", "indeterminate", "invalid"];
-var SlashOutcomeZod = z25.literal(SlashOutcomes);
+var SlashOutcomeZod = z26.literal(SlashOutcomes);
 var SlashAdjudicationSchema = asSchema17("network.xyo.chain.slash.adjudication", true);
-var SlashAdjudicationFieldsZod = z25.object({
+var SlashAdjudicationFieldsZod = z26.object({
   /** Address credited with the report, required once bounties are paid. */
-  claimant: z25.optional(XyoAddressZod6),
+  claimant: z26.optional(XyoAddressZod6),
   /** Hash of the commitment that won the claim. */
-  claimantCommit: z25.optional(HashZod6),
+  claimantCommit: z26.optional(HashZod6),
   /** Address issuing the adjudication. */
   from: XyoAddressZod6,
   /** How the request was resolved. */
   outcome: SlashOutcomeZod,
   /** Why, for any outcome other than confirmed. */
-  reason: z25.optional(z25.string()),
+  reason: z26.optional(z26.string()),
   /** Hash of the request being adjudicated. */
   request: HashZod6
 });
@@ -746,11 +773,11 @@ import {
   isPayloadOfZodType as isPayloadOfZodType13,
   XyoAddressZod as XyoAddressZod7
 } from "@xyo-network/sdk";
-import { z as z26 } from "zod/mini";
+import { z as z27 } from "zod/mini";
 var SlashChallengeSchema = asSchema18("network.xyo.chain.slash.challenge", true);
-var SlashChallengeFieldsZod = z26.object({
+var SlashChallengeFieldsZod = z27.object({
   /** Hashes of the counter-artifacts, carried in accompanying evidence payloads. */
-  evidence: z26.array(HashZod7),
+  evidence: z27.array(HashZod7),
   /** Address filing the challenge. */
   from: XyoAddressZod7,
   /** Hash of the request being challenged. */
@@ -766,9 +793,9 @@ import {
   isPayloadOfZodType as isPayloadOfZodType14,
   XyoAddressZod as XyoAddressZod8
 } from "@xyo-network/sdk";
-import { z as z27 } from "zod/mini";
+import { z as z28 } from "zod/mini";
 var SlashCommitSchema = asSchema19("network.xyo.chain.slash.commit", true);
-var SlashCommitFieldsZod = z27.object({
+var SlashCommitFieldsZod = z28.object({
   /** Hash of the report this commitment reserves. */
   commitment: HashZod8,
   /** Address that will file the report. */
@@ -784,11 +811,11 @@ import {
   isPayloadOfZodType as isPayloadOfZodType15,
   XyoAddressZod as XyoAddressZod9
 } from "@xyo-network/sdk";
-import { z as z28 } from "zod/mini";
+import { z as z29 } from "zod/mini";
 var SlashEvidenceSchema = asSchema20("network.xyo.chain.slash.evidence", true);
-var SlashEvidenceFieldsZod = z28.object({
+var SlashEvidenceFieldsZod = z29.object({
   /** The signed artifacts, exactly as they were observed. */
-  artifacts: z28.array(z28.record(z28.string(), z28.unknown())),
+  artifacts: z29.array(z29.record(z29.string(), z29.unknown())),
   /** Address that submitted the evidence. */
   from: XyoAddressZod9
 });
@@ -802,10 +829,10 @@ import {
   isPayloadOfZodType as isPayloadOfZodType16,
   XyoAddressZod as XyoAddressZod10
 } from "@xyo-network/sdk";
-import { z as z30 } from "zod/mini";
+import { z as z31 } from "zod/mini";
 
 // src/modules/protocol-model/model/OffenseCode.ts
-import { z as z29 } from "zod/mini";
+import { z as z30 } from "zod/mini";
 var OffenseCodes = [
   "equivocation",
   "invalid-block",
@@ -815,23 +842,23 @@ var OffenseCodes = [
   "invalid-slash-request",
   "false-attestation"
 ];
-var OffenseCodeZod = z29.literal(OffenseCodes);
+var OffenseCodeZod = z30.literal(OffenseCodes);
 
 // src/modules/protocol-model/payload/slash/SlashRequestPayload.ts
 var SlashRequestSchema = asSchema21("network.xyo.chain.slash.request", true);
-var SlashRequestFieldsZod = z30.object({
+var SlashRequestFieldsZod = z31.object({
   /** Address accused of the offense. */
   accused: XyoAddressZod10,
   /** Height the offense occurred at. */
   block: XL1BlockNumberZod,
   /** Catalog version the offense is judged under. */
-  catalog: z30.number().check(z30.multipleOf(1), z30.positive()),
+  catalog: z31.number().check(z31.multipleOf(1), z31.positive()),
   /** Chain the offense occurred on. */
   chain: ChainIdZod,
   /** Hashes of the artifacts proving the offense, carried in accompanying evidence payloads. */
-  evidence: z30.array(HashZod9),
+  evidence: z31.array(HashZod9),
   /** EVM height the claim is judged against, for anchor and eligibility offenses. */
-  evm: z30.optional(z30.number()),
+  evm: z31.optional(z31.number()),
   /** Address filing the report. */
   from: XyoAddressZod10,
   /** Offense class being alleged. */
@@ -846,10 +873,10 @@ import { asSchema as asSchema22, isPayloadOfZodType as isPayloadOfZodType17 } fr
 
 // src/modules/protocol-model/Step/StepIdentity.ts
 import { isUndefined } from "@ariestools/sdk";
-import { z as z31 } from "zod";
-var StepIdentityZod = z31.object({
+import { z as z32 } from "zod";
+var StepIdentityZod = z32.object({
   block: XL1BlockNumberZod.describe("The block number at which the step occurs"),
-  step: z31.number().int().nonnegative().describe("The index of the step into the StepSize array")
+  step: z32.number().int().nonnegative().describe("The index of the step into the StepSize array")
 });
 function tryParseInt(value) {
   if (value === "") return void 0;
@@ -926,9 +953,9 @@ import {
   isPayloadOfZodType as isPayloadOfZodType18,
   XyoAddressZod as XyoAddressZod11
 } from "@xyo-network/sdk";
-import { z as z32 } from "zod/mini";
+import { z as z33 } from "zod/mini";
 var StepWitnessSchema = asSchema23("network.xyo.chain.validation.step.witness", true);
-var StepWitnessFieldsZod = z32.object({
+var StepWitnessFieldsZod = z33.object({
   /** Hash of the block in which the step hash was observed */
   blockHash: HashZod10,
   /** Block number of the block in which the step hash was observed */
@@ -936,7 +963,7 @@ var StepWitnessFieldsZod = z32.object({
   /** The observed step hash — the entry at the step level's index in the block's step_hashes */
   stepHash: HashZod10,
   /** Block-interval size of the observed step level — must be one of StepSizes */
-  stepSize: z32.literal(StepSizes),
+  stepSize: z33.literal(StepSizes),
   /** Address of the observer */
   witness: XyoAddressZod11
 });
@@ -965,7 +992,7 @@ import {
   AsObjectFactory as AsObjectFactory24,
   HexZod as HexZod6,
   JsonObjectZod,
-  zodIsFactory as zodIsFactory5
+  zodIsFactory as zodIsFactory6
 } from "@ariestools/sdk";
 import {
   asSchema as asSchema24,
@@ -973,19 +1000,25 @@ import {
   PayloadZodOfSchema as PayloadZodOfSchema3,
   XyoAddressZod as XyoAddressZod12
 } from "@xyo-network/sdk";
-import { z as z33 } from "zod/mini";
+import { z as z34 } from "zod/mini";
 var TransferSchema = asSchema24("network.xyo.transfer", true);
-var TransferFieldsZod = z33.object({
+var TransferFieldsZod = z34.object({
   // Removed as only transaction have opCodes
   // $opCodes: z.array(z.string()).optional(),
-  context: z33.optional(JsonObjectZod),
-  epoch: z33.number(),
+  context: z34.optional(JsonObjectZod),
+  epoch: z34.number(),
   from: XyoAddressZod12,
-  transfers: z33.record(XyoAddressZod12, HexZod6)
+  transfers: z34.record(XyoAddressZod12, HexZod6)
 });
-var TransferZod = z33.extend(PayloadZodOfSchema3(TransferSchema), TransferFieldsZod.shape);
-var isTransfer = isPayloadOfSchemaType6(TransferSchema);
-var isTransferPayload = zodIsFactory5(TransferZod);
+var TransferZod = z34.extend(PayloadZodOfSchema3(TransferSchema), {
+  ...TransferFieldsZod.shape,
+  ...Xl1PayloadVersionFieldsZod.shape
+});
+var isTransferOfSchema = isPayloadOfSchemaType6(TransferSchema);
+var isTransfer = (value) => {
+  return isXl1PayloadVersionSupported(value) && isTransferOfSchema(value);
+};
+var isTransferPayload = zodIsFactory6(TransferZod);
 var asTransfer = AsObjectFactory24.create(isTransfer);
 var asTransferPayload = AsObjectFactory24.create(isTransferPayload);
 
@@ -1009,9 +1042,10 @@ var AllowedBlockPayloadSchemas = [
   TimeSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadSchemaZod = z34.enum(AllowedBlockPayloadSchemas);
-var isAllowedBlockPayloadSchema = zodIsFactory6(AllowedBlockPayloadSchemaZod);
+var AllowedBlockPayloadSchemaZod = z35.enum(AllowedBlockPayloadSchemas);
+var isAllowedBlockPayloadSchema = zodIsFactory7(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (value) => {
+  if (!isXl1PayloadVersionSupported(value)) return false;
   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) => {
@@ -1022,7 +1056,7 @@ var isAllowedBlockPayloadWithHashMeta = (value) => {
 import {
   HashZod as HashZod11,
   zodAsFactory as zodAsFactory7,
-  zodIsFactory as zodIsFactory7,
+  zodIsFactory as zodIsFactory8,
   zodToFactory as zodToFactory7
 } from "@ariestools/sdk";
 import {
@@ -1030,13 +1064,13 @@ import {
   WithHashMetaZod as WithHashMetaZod2,
   WithStorageMetaZod as WithStorageMetaZod2
 } from "@xyo-network/sdk";
-import { z as z35 } from "zod/mini";
-var BlockBoundWitnessFieldsZod = z35.object({
+import { z as z36 } from "zod/mini";
+var BlockBoundWitnessFieldsZod = z36.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: z35.nullable(HashZod11),
-  protocol: z35.optional(z35.number()),
-  step_hashes: z35.optional(z35.array(HashZod11)),
+  previous: z36.nullable(HashZod11),
+  protocol: z36.optional(z36.number()),
+  step_hashes: z36.optional(z36.array(HashZod11)),
   /**
    * Signed hash of the same-height candidate this block replaces.
    *
@@ -1044,30 +1078,32 @@ var BlockBoundWitnessFieldsZod = z35.object({
    * honest re-proposal from double-signing, and a producer must not be able to add or drop it
    * after the fact.
    */
-  supersedes: z35.optional(HashZod11)
+  supersedes: z36.optional(HashZod11)
 });
-var BlockBoundWitnessMetaZod = z35.object({ $epoch: z35.number() });
-var BlockBoundWitnessZod = z35.object({
+var BlockBoundWitnessMetaZod = z36.object({ ...Xl1PayloadVersionFieldsZod.shape, $epoch: z36.number() });
+var BlockBoundWitnessZod = z36.object({
   ...BoundWitnessZod2.shape,
   ...BlockBoundWitnessFieldsZod.shape,
   ...BlockBoundWitnessMetaZod.shape
 });
-var isBlockBoundWitness = zodIsFactory7(BlockBoundWitnessZod);
+var isBlockBoundWitness = zodIsFactory8(BlockBoundWitnessZod);
 var asBlockBoundWitness = zodAsFactory7(BlockBoundWitnessZod, "asBlockBoundWitness");
 var toBlockBoundWitness = zodToFactory7(BlockBoundWitnessZod, "toBlockBoundWitness");
-var BlockBoundWitnessWithHashMetaZod = WithHashMetaZod2(BlockBoundWitnessZod);
-var isBlockBoundWitnessWithHashMeta = zodIsFactory7(WithHashMetaZod2(BlockBoundWitnessZod));
+var blockBoundWitnessWithHashMetaZod = WithHashMetaZod2(BlockBoundWitnessZod);
+var BlockBoundWitnessWithHashMetaZod = blockBoundWitnessWithHashMetaZod;
+var isBlockBoundWitnessWithHashMeta = zodIsFactory8(WithHashMetaZod2(BlockBoundWitnessZod));
 var asBlockBoundWitnessWithHashMeta = zodAsFactory7(WithHashMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithHashMeta");
 var toBlockBoundWitnessWithHashMeta = zodToFactory7(WithHashMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithHashMeta");
-var BlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod2(BlockBoundWitnessZod);
-var isBlockBoundWitnessWithStorageMeta = zodIsFactory7(WithStorageMetaZod2(BlockBoundWitnessZod));
+var blockBoundWitnessWithStorageMetaZod = WithStorageMetaZod2(BlockBoundWitnessZod);
+var BlockBoundWitnessWithStorageMetaZod = blockBoundWitnessWithStorageMetaZod;
+var isBlockBoundWitnessWithStorageMeta = zodIsFactory8(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 zodIsFactory11,
+  zodIsFactory as zodIsFactory12,
   zodToFactory as zodToFactory11
 } from "@ariestools/sdk";
 import {
@@ -1076,38 +1112,38 @@ import {
   WithHashMetaZod as WithHashMetaZod4,
   WithStorageMetaZod as WithStorageMetaZod4
 } from "@xyo-network/sdk";
-import { z as z39 } from "zod/mini";
+import { z as z40 } from "zod/mini";
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitness.ts
 import {
   zodAsFactory as zodAsFactory8,
-  zodIsFactory as zodIsFactory8,
+  zodIsFactory as zodIsFactory9,
   zodToFactory as zodToFactory8
 } from "@ariestools/sdk";
 import { SignedBoundWitnessZod as SignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z36 } from "zod/mini";
-var SignedBlockBoundWitnessZod = z36.safeExtend(
-  z36.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z37 } from "zod/mini";
+var SignedBlockBoundWitnessZod = z37.safeExtend(
+  z37.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
-var isSignedBlockBoundWitness = zodIsFactory8(SignedBlockBoundWitnessZod);
+var isSignedBlockBoundWitness = zodIsFactory9(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 zodIsFactory9,
+  zodIsFactory as zodIsFactory10,
   zodToFactory as zodToFactory9
 } from "@ariestools/sdk";
 import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk";
-import { z as z37 } from "zod/mini";
+import { z as z38 } from "zod/mini";
 var SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod3(SignedBlockBoundWitnessZod);
-var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory9(SignedBlockBoundWitnessWithHashMetaZod);
+var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory10(SignedBlockBoundWitnessWithHashMetaZod);
 var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory9(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
-var SignedBlockBoundWitnessWithHashMetaishZod = z37.pipe(
+var SignedBlockBoundWitnessWithHashMetaishZod = z38.pipe(
   SignedBlockBoundWitnessZod,
-  z37.transform(async (data) => {
+  z38.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithHashMeta(data)) {
       return data;
     }
@@ -1122,20 +1158,20 @@ var toSignedBlockBoundWitnessWithHashMeta = zodToFactory9(SignedBlockBoundWitnes
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts
 import {
   zodAsFactory as zodAsFactory10,
-  zodIsFactory as zodIsFactory10,
+  zodIsFactory as zodIsFactory11,
   zodToFactory as zodToFactory10
 } from "@ariestools/sdk";
 import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod3 } from "@xyo-network/sdk";
-import { z as z38 } from "zod/mini";
+import { z as z39 } from "zod/mini";
 var SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod3(SignedBlockBoundWitnessZod);
-var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory10(SignedBlockBoundWitnessWithStorageMetaZod);
+var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory11(SignedBlockBoundWitnessWithStorageMetaZod);
 var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory10(
   SignedBlockBoundWitnessWithStorageMetaZod,
   "asSignedBlockBoundWitnessWithStorageMeta"
 );
-var SignedBlockBoundWitnessWithStorageMetaishZod = z38.pipe(
+var SignedBlockBoundWitnessWithStorageMetaishZod = z39.pipe(
   SignedBlockBoundWitnessZod,
-  z38.transform(async (data) => {
+  z39.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
       return data;
     }
@@ -1151,77 +1187,77 @@ var toSignedBlockBoundWitnessWithStorageMeta = zodToFactory10(
 );
 
 // src/modules/protocol-model/block/HydratedBlock.ts
-var HydratedBlockZod = z39.tuple([
+var HydratedBlockZod = z40.tuple([
   BlockBoundWitnessZod,
-  z39.array(PayloadZodLoose)
+  z40.array(PayloadZodLoose)
 ]);
-var isHydratedBlock = zodIsFactory11(HydratedBlockZod);
+var isHydratedBlock = zodIsFactory12(HydratedBlockZod);
 var asHydratedBlock = zodAsFactory11(HydratedBlockZod, "asHydratedBlock");
 var toHydratedBlock = zodToFactory11(HydratedBlockZod, "toHydratedBlock");
-var HydratedBlockWithHashMetaZod = z39.tuple([
+var HydratedBlockWithHashMetaZod = z40.tuple([
   WithHashMetaZod4(BlockBoundWitnessZod),
-  z39.array(z39.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z40.array(z40.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var isHydratedBlockWithHashMeta = zodIsFactory11(HydratedBlockWithHashMetaZod);
+var isHydratedBlockWithHashMeta = zodIsFactory12(HydratedBlockWithHashMetaZod);
 var asHydratedBlockWithHashMeta = zodAsFactory11(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
 var toHydratedBlockWithHashMeta = zodToFactory11(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
-var HydratedBlockWithStorageMetaZod = z39.tuple([
+var HydratedBlockWithStorageMetaZod = z40.tuple([
   WithStorageMetaZod4(BlockBoundWitnessZod),
-  z39.array(z39.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z40.array(z40.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
-var isHydratedBlockWithStorageMeta = zodIsFactory11(HydratedBlockWithStorageMetaZod);
+var isHydratedBlockWithStorageMeta = zodIsFactory12(HydratedBlockWithStorageMetaZod);
 var asHydratedBlockWithStorageMeta = zodAsFactory11(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
 var toHydratedBlockWithStorageMeta = zodToFactory11(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
-var SignedHydratedBlockZod = z39.tuple([
+var SignedHydratedBlockZod = z40.tuple([
   SignedBlockBoundWitnessZod,
-  z39.array(z39.looseObject(PayloadZod.shape))
+  z40.array(z40.looseObject(PayloadZod.shape))
 ]);
-var isSignedHydratedBlock = zodIsFactory11(SignedHydratedBlockZod);
+var isSignedHydratedBlock = zodIsFactory12(SignedHydratedBlockZod);
 var asSignedHydratedBlock = zodAsFactory11(SignedHydratedBlockZod, "asSignedHydratedBlock");
 var toSignedHydratedBlock = zodToFactory11(SignedHydratedBlockZod, "toSignedHydratedBlock");
-var SignedHydratedBlockToJsonZod = z39.tuple([
+var SignedHydratedBlockToJsonZod = z40.tuple([
   SignedBlockBoundWitnessZod,
-  z39.array(z39.looseObject(PayloadZod.shape))
+  z40.array(z40.looseObject(PayloadZod.shape))
 ]);
-var isSignedHydratedBlockToJson = zodIsFactory11(SignedHydratedBlockToJsonZod);
+var isSignedHydratedBlockToJson = zodIsFactory12(SignedHydratedBlockToJsonZod);
 var asSignedHydratedBlockToJson = zodAsFactory11(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
 var toSignedHydratedBlockToJson = zodToFactory11(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
-var SignedHydratedBlockWithHashMetaZod = z39.tuple([
+var SignedHydratedBlockWithHashMetaZod = z40.tuple([
   WithHashMetaZod4(SignedBlockBoundWitnessZod),
-  z39.array(z39.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z40.array(z40.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var SignedHydratedBlockWithHashMetaishZod = z39.tuple([
-  z39.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
-  z39.array(z39.looseObject(WithHashMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithHashMetaishZod = z40.tuple([
+  z40.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
+  z40.array(z40.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var isSignedHydratedBlockWithHashMeta = zodIsFactory11(SignedHydratedBlockWithHashMetaZod);
+var isSignedHydratedBlockWithHashMeta = zodIsFactory12(SignedHydratedBlockWithHashMetaZod);
 var asSignedHydratedBlockWithHashMeta = zodAsFactory11(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
 var toSignedHydratedBlockWithHashMeta = zodToFactory11(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
-var SignedHydratedBlockWithStorageMetaZod = z39.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z40.tuple([
   WithStorageMetaZod4(SignedBlockBoundWitnessZod),
-  z39.array(z39.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z40.array(z40.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
-var isSignedHydratedBlockWithStorageMeta = zodIsFactory11(SignedHydratedBlockWithStorageMetaZod);
+var isSignedHydratedBlockWithStorageMeta = zodIsFactory12(SignedHydratedBlockWithStorageMetaZod);
 var asSignedHydratedBlockWithStorageMeta = zodAsFactory11(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
 var toSignedHydratedBlockWithStorageMeta = zodToFactory11(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
-var SignedHydratedBlockWithStorageMetaishZod = z39.tuple([
-  z39.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
-  z39.array(z39.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithStorageMetaishZod = z40.tuple([
+  z40.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
+  z40.array(z40.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 
 // src/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.ts
 import {
   zodAsFactory as zodAsFactory12,
-  zodIsFactory as zodIsFactory12,
+  zodIsFactory as zodIsFactory13,
   zodToFactory as zodToFactory12
 } from "@ariestools/sdk";
 import { UnsignedBoundWitnessZod as UnsignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z40 } from "zod/mini";
-var UnsignedBlockBoundWitnessZod = z40.safeExtend(
-  z40.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z41 } from "zod/mini";
+var UnsignedBlockBoundWitnessZod = z41.safeExtend(
+  z41.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
-var isUnsignedBlockBoundWitness = zodIsFactory12(UnsignedBlockBoundWitnessZod);
+var isUnsignedBlockBoundWitness = zodIsFactory13(UnsignedBlockBoundWitnessZod);
 var asUnsignedBlockBoundWitness = zodAsFactory12(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
 var toUnsignedBlockBoundWitness = zodToFactory12(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
 
@@ -1232,9 +1268,9 @@ import {
   isPayloadOfZodType as isPayloadOfZodType19,
   XyoAddressZod as XyoAddressZod13
 } from "@xyo-network/sdk";
-import { z as z41 } from "zod/mini";
+import { z as z42 } from "zod/mini";
 var CandidatePairSchema = asSchema25("network.xyo.chain.evidence.candidate.pair", true);
-var CandidatePairFieldsZod = z41.object({
+var CandidatePairFieldsZod = z42.object({
   /** Chain both candidates were proposed on */
   chain: ChainIdZod,
   /** Block number both candidates claim */
@@ -1242,7 +1278,7 @@ var CandidatePairFieldsZod = z41.object({
   /** Address that signed both candidates */
   producer: XyoAddressZod13,
   /** The two candidates' recomputed bound witness data hashes, sorted ascending */
-  subjects: z41.tuple([HashZod12, HashZod12])
+  subjects: z42.tuple([HashZod12, HashZod12])
 });
 var isCandidatePair = isPayloadOfZodType19(CandidatePairFieldsZod, CandidatePairSchema);
 var asCandidatePair = AsObjectFactory25.create(isCandidatePair);
@@ -1254,15 +1290,15 @@ import {
   isPayloadOfZodType as isPayloadOfZodType20,
   XyoAddressZod as XyoAddressZod14
 } from "@xyo-network/sdk";
-import { z as z42 } from "zod/mini";
+import { z as z43 } from "zod/mini";
 var CandidateSeenSchema = asSchema26("network.xyo.chain.evidence.candidate", true);
-var CandidateSeenFieldsZod = z42.object({
+var CandidateSeenFieldsZod = z43.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: z42.optional(HashZod13),
+  previous: z43.optional(HashZod13),
   /** Address that signed the candidate */
   producer: XyoAddressZod14,
   /** Recomputed data hash of the candidate's bound witness */
@@ -1272,7 +1308,7 @@ var isCandidateSeen = isPayloadOfZodType20(CandidateSeenFieldsZod, CandidateSeen
 var asCandidateSeen = AsObjectFactory26.create(isCandidateSeen);
 
 // src/modules/protocol-model/evidence/EvidenceDisposition.ts
-import { z as z43 } from "zod/mini";
+import { z as z44 } from "zod/mini";
 var EvidenceDispositions = [
   "expired",
   "finalized",
@@ -1282,7 +1318,7 @@ var EvidenceDispositions = [
   "malformed",
   "superseded"
 ];
-var EvidenceDispositionZod = z43.literal(EvidenceDispositions);
+var EvidenceDispositionZod = z44.literal(EvidenceDispositions);
 
 // src/modules/protocol-model/evidence/EvidenceNotePayload.ts
 import { AsObjectFactory as AsObjectFactory27, HashZod as HashZod14 } from "@ariestools/sdk";
@@ -1291,19 +1327,19 @@ import {
   isPayloadOfZodType as isPayloadOfZodType21,
   XyoAddressZod as XyoAddressZod15
 } from "@xyo-network/sdk";
-import { z as z44 } from "zod/mini";
+import { z as z45 } from "zod/mini";
 var EvidenceNoteSchema = asSchema27("network.xyo.chain.evidence.note", true);
-var EvidenceNoteFieldsZod = z44.object({
+var EvidenceNoteFieldsZod = z45.object({
   /** Hash of the stored bundle payload this note describes */
   bundle: HashZod14,
   /** Why the candidate left the pending pool */
   disposition: EvidenceDispositionZod,
   /** Block number of the archived candidate — absent when the bundle was malformed */
-  height: z44.optional(XL1BlockNumberZod),
+  height: z45.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: z44.optional(XyoAddressZod15),
+  producer: z45.optional(XyoAddressZod15),
   /** Recomputed data hash of the archived block's bound witness — the artifact identity evidence references use */
   subject: HashZod14
 });
@@ -1324,13 +1360,13 @@ var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumb
 var asBlockNumberPayloadWithSources = AsObjectFactory28.create(isBlockNumberPayloadWithSources);
 
 // src/modules/protocol-model/model/AccountBalance.ts
-import { zodIsFactory as zodIsFactory15 } from "@ariestools/sdk";
+import { zodIsFactory as zodIsFactory16 } from "@ariestools/sdk";
 import { WithHashMetaZod as WithHashMetaZod5 } from "@xyo-network/sdk";
-import { z as z50 } from "zod/mini";
+import { z as z51 } from "zod/mini";
 
 // src/modules/protocol-model/model/ChainQualification.ts
-import { HashZod as HashZod15, zodIsFactory as zodIsFactory14 } from "@ariestools/sdk";
-import { z as z49 } from "zod";
+import { HashZod as HashZod15, zodIsFactory as zodIsFactory15 } from "@ariestools/sdk";
+import { z as z50 } from "zod";
 
 // src/modules/protocol-model/model/BlockRange/BlockRange.ts
 import {
@@ -1339,9 +1375,9 @@ import {
   zodAsFactory as zodAsFactory13,
   zodToFactory as zodToFactory13
 } from "@ariestools/sdk";
-import { z as z45 } from "zod";
-var BlockRangeZod = z45.tuple([BlockNumberZod, BlockNumberZod]);
-var BlockRangeishZod = z45.tuple([BlockNumberishZod, BlockNumberishZod]);
+import { z as z46 } from "zod";
+var BlockRangeZod = z46.tuple([BlockNumberZod, BlockNumberZod]);
+var BlockRangeishZod = z46.tuple([BlockNumberishZod, BlockNumberishZod]);
 var asBlockRange = zodAsFactory13(BlockRangeZod, "BlockRange");
 var toBlockRange = zodToFactory13(BlockRangeishZod, "BlockRange");
 var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1358,9 +1394,9 @@ import {
   zodAsFactory as zodAsFactory14,
   zodToFactory as zodToFactory14
 } from "@ariestools/sdk";
-import { z as z46 } from "zod";
-var EthBlockRangeZod = z46.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-var EthBlockRangeishZod = z46.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
+import { z as z47 } from "zod";
+var EthBlockRangeZod = z47.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var EthBlockRangeishZod = z47.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
 var asEthBlockRange = zodAsFactory14(EthBlockRangeZod, "EthBlockRange");
 var toEthBlockRange = zodToFactory14(EthBlockRangeishZod, "EthBlockRange");
 var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1373,12 +1409,12 @@ function fromEthBlockNumberKey(key, assert) {
 // src/modules/protocol-model/model/BlockRange/Range.ts
 import {
   zodAsFactory as zodAsFactory15,
-  zodIsFactory as zodIsFactory13,
+  zodIsFactory as zodIsFactory14,
   zodToFactory as zodToFactory15
 } from "@ariestools/sdk";
-import { z as z47 } from "zod";
-var RangeZod = z47.tuple([z47.number(), z47.number()]);
-var isRange = zodIsFactory13(RangeZod);
+import { z as z48 } from "zod";
+var RangeZod = z48.tuple([z48.number(), z48.number()]);
+var isRange = zodIsFactory14(RangeZod);
 var asRange = zodAsFactory15(RangeZod, "Range");
 var toRange = zodToFactory15(RangeZod, "Range");
 
@@ -1389,9 +1425,9 @@ import {
   zodAsFactory as zodAsFactory16,
   zodToFactory as zodToFactory16
 } from "@ariestools/sdk";
-import { z as z48 } from "zod";
-var XL1BlockRangeZod = z48.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-var XL1BlockRangeishZod = z48.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
+import { z as z49 } from "zod";
+var XL1BlockRangeZod = z49.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var XL1BlockRangeishZod = z49.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
 var asXL1BlockRange = zodAsFactory16(XL1BlockRangeZod, "XL1BlockRange");
 var toXL1BlockRange = zodToFactory16(XL1BlockRangeishZod, "XL1BlockRange");
 var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1402,33 +1438,33 @@ function fromXL1BlockNumberKey(key, assert) {
 }
 
 // src/modules/protocol-model/model/ChainQualification.ts
-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 ChainQualificationZod = z50.object({ head: HashZod15, range: XL1BlockRangeZod });
+var isChainQualification = zodIsFactory15(ChainQualificationZod);
+var ChainQualifiedRangeConfigZod = z50.object({ range: XL1BlockRangeZod });
+var isChainQualifiedRangeConfig = zodIsFactory15(ChainQualifiedRangeConfigZod);
+var ChainQualifiedHeadConfigZod = z50.object({ head: HashZod15 });
+var isChainQualifiedHeadConfig = zodIsFactory15(ChainQualifiedHeadConfigZod);
+var ChainQualifiedConfigZod = z50.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z50.object({})]);
+var isChainQualifiedConfig = zodIsFactory15(ChainQualifiedConfigZod);
 var ExtendChainQualifiedConfigZod = ((zodType) => {
-  return z49.union([
+  return z50.union([
     ChainQualifiedRangeConfigZod.extend(zodType),
     ChainQualifiedHeadConfigZod.extend(zodType),
     zodType
   ]);
 });
 var ChainQualifiedZod = (zodType) => {
-  return z49.tuple([zodType, ChainQualificationZod]);
+  return z50.tuple([zodType, ChainQualificationZod]);
 };
 
 // src/modules/protocol-model/model/AccountBalance.ts
-var AccountBalanceHistoryItemZod = z50.tuple([
+var AccountBalanceHistoryItemZod = z51.tuple([
   WithHashMetaZod5(BlockBoundWitnessZod),
-  z50.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
+  z51.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
   WithHashMetaZod5(TransferZod)
 ]);
 var AccountBalanceConfigZod = ChainQualifiedConfigZod;
-var isAccountBalanceConfig = zodIsFactory15(AccountBalanceConfigZod);
+var isAccountBalanceConfig = zodIsFactory16(AccountBalanceConfigZod);
 var AccountBalanceViewerMoniker = "AccountBalanceViewer";
 
 // src/modules/protocol-model/model/addresses.ts
@@ -1443,51 +1479,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 z51 } from "zod";
+import { z as z52 } from "zod";
 function base64Encode(u8) {
   return u8.toBase64();
 }
 function base64Decode(b64) {
   return Uint8Array.fromBase64(b64);
 }
-var ArrayBufferToJsonZod = z51.instanceof(ArrayBuffer).transform((x) => {
+var ArrayBufferToJsonZod = z52.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
 });
-var JsonToArrayBufferZod = z51.string().transform((x) => {
+var JsonToArrayBufferZod = z52.string().transform((x) => {
   const u8 = base64Decode(x);
   return u8.buffer;
 });
 
 // src/modules/protocol-model/model/BlockRate.ts
-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()
+import { zodAsFactory as zodAsFactory17, zodIsFactory as zodIsFactory17 } from "@ariestools/sdk";
+import { z as z53 } from "zod";
+var TimeDurationsZod = z53.object({
+  millis: z53.number().nonnegative(),
+  seconds: z53.number().nonnegative(),
+  minutes: z53.number().nonnegative(),
+  hours: z53.number().nonnegative(),
+  days: z53.number().nonnegative(),
+  weeks: z53.number().nonnegative()
 });
-var isTimeDurations = zodIsFactory16(TimeDurationsZod);
+var isTimeDurations = zodIsFactory17(TimeDurationsZod);
 var asTimeDurations = zodAsFactory17(TimeDurationsZod, "asTimeDurations");
 var toTimeDurations = zodAsFactory17(TimeDurationsZod, "toTimeDurations");
-var BlockRateZod = z52.object({
+var BlockRateZod = z53.object({
   range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
-  rate: z52.number().nonnegative().describe("rate of blocks per specified time unit"),
+  rate: z53.number().nonnegative().describe("rate of blocks per specified time unit"),
   timeUnit: TimeDurationsZod.keyof().describe("the unit of time for the rate and timePerBlock"),
-  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")
+  span: z53.int().nonnegative().describe("number of blocks the rate was calculated over"),
+  timeDifference: z53.number().nonnegative().describe("time difference from start and end block"),
+  timePerBlock: z53.number().nonnegative().describe("average time per block for the given range")
 });
-var isBlockRate = zodIsFactory16(BlockRateZod);
+var isBlockRate = zodIsFactory17(BlockRateZod);
 var asBlockRate = zodAsFactory17(BlockRateZod, "asBlockRate");
 var toBlockRate = zodAsFactory17(BlockRateZod, "toBlockRate");
-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({
+var CountZod = z53.int().nonnegative().describe("A non-negative integer count");
+var StepIndexZod = z53.int().min(0).max(StepSizes.length - 1).describe("A non-negative integer step index");
+var timeUnitSchema = z53.number().positive();
+var TimeConfigZod = z53.object({
   minutes: timeUnitSchema.optional(),
   hours: timeUnitSchema.optional(),
   days: timeUnitSchema.optional(),
@@ -1495,33 +1531,33 @@ var TimeConfigZod = z52.object({
   months: timeUnitSchema.optional(),
   years: timeUnitSchema.optional()
 }).describe("Time configuration with optional time units");
-var isTimeConfig = zodIsFactory16(TimeConfigZod);
+var isTimeConfig = zodIsFactory17(TimeConfigZod);
 var asTimeConfig = zodAsFactory17(TimeConfigZod, "asTimeConfig");
 var toTimeConfig = zodAsFactory17(TimeConfigZod, "toTimeConfig");
-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 })
+var SingleTimeConfigZod = z53.union([
+  z53.object({ minutes: timeUnitSchema }),
+  z53.object({ hours: timeUnitSchema }),
+  z53.object({ days: timeUnitSchema }),
+  z53.object({ weeks: timeUnitSchema }),
+  z53.object({ months: timeUnitSchema }),
+  z53.object({ years: timeUnitSchema })
 ]).describe("Time configuration with exactly one time unit");
-var isSingleTimeConfig = zodIsFactory16(SingleTimeConfigZod);
+var isSingleTimeConfig = zodIsFactory17(SingleTimeConfigZod);
 var asSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "asSingleTimeConfig");
 var toSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "toSingleTimeConfig");
 
 // src/modules/protocol-model/model/Context/BaseContext.zod.ts
-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))
+import { z as z54 } from "zod";
+var CachesZod = z54.record(
+  z54.string(),
+  z54.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
 );
-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({
+var SingletonsZod = z54.record(z54.union([z54.string(), z54.symbol()]), z54.unknown());
+var LoggerZod = z54.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
+var MeterProviderZod = z54.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
+var TracerProviderZod = z54.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
+var TimeBudgetLimitZod = z54.number();
+var BaseContextZod = z54.object({
   caches: CachesZod.optional(),
   logger: LoggerZod.optional(),
   meterProvider: MeterProviderZod.optional(),
@@ -1531,24 +1567,24 @@ var BaseContextZod = z53.object({
 });
 
 // src/modules/protocol-model/model/Context/BlockContext.zod.ts
-import z54 from "zod";
+import z55 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: z54.custom((val) => val != null && typeof val === "object" && "get" in val) }
+  { chainMap: z55.custom((val) => val != null && typeof val === "object" && "get" in val) }
 );
 var BlockContextWriteZod = CachingContextZod.extend(
-  { chainMap: z54.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
+  { chainMap: z55.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 z55 from "zod";
-var HeadContextBaseZod = z55.object(
+import z56 from "zod";
+var HeadContextBaseZod = z56.object(
   { head: WithHashMetaZod6(BlockBoundWitnessZod) }
 );
 var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
@@ -1584,7 +1620,7 @@ var defaultTransactionFees = {
 // src/modules/protocol-model/model/HydratedTransaction.ts
 import {
   zodAsFactory as zodAsFactory18,
-  zodIsFactory as zodIsFactory17,
+  zodIsFactory as zodIsFactory18,
   zodToFactory as zodToFactory17
 } from "@ariestools/sdk";
 import {
@@ -1593,47 +1629,47 @@ import {
   WithHashMetaZod as WithHashMetaZod7,
   WithStorageMetaZod as WithStorageMetaZod5
 } from "@xyo-network/sdk";
-import { z as z56 } from "zod/mini";
-var HydratedTransactionZod = z56.tuple([
+import { z as z57 } from "zod/mini";
+var HydratedTransactionZod = z57.tuple([
   TransactionBoundWitnessZod,
-  z56.array(PayloadZodLoose2)
+  z57.array(PayloadZodLoose2)
 ]);
-var isHydratedTransaction = zodIsFactory17(HydratedTransactionZod);
+var isHydratedTransaction = zodIsFactory18(HydratedTransactionZod);
 var asHydratedTransaction = zodAsFactory18(HydratedTransactionZod, "asHydratedTransaction");
 var toHydratedTransaction = zodToFactory17(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z56.tuple([
+var HydratedTransactionWithHashMetaZod = z57.tuple([
   WithHashMetaZod7(TransactionBoundWitnessZod),
-  z56.array(z56.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z57.array(z57.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isHydratedTransactionWithHashMeta = zodIsFactory17(HydratedTransactionWithHashMetaZod);
+var isHydratedTransactionWithHashMeta = zodIsFactory18(HydratedTransactionWithHashMetaZod);
 var asHydratedTransactionWithHashMeta = zodAsFactory18(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
 var toHydratedTransactionWithHashMeta = zodToFactory17(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z56.tuple([
+var HydratedTransactionWithStorageMetaZod = z57.tuple([
   WithStorageMetaZod5(TransactionBoundWitnessZod),
-  z56.array(z56.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z57.array(z57.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isHydratedTransactionWithStorageMeta = zodIsFactory17(HydratedTransactionWithStorageMetaZod);
+var isHydratedTransactionWithStorageMeta = zodIsFactory18(HydratedTransactionWithStorageMetaZod);
 var asHydratedTransactionWithStorageMeta = zodAsFactory18(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
 var toHydratedTransactionWithStorageMeta = zodToFactory17(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z56.tuple([
+var UnsignedHydratedTransactionZod = z57.tuple([
   UnsignedTransactionBoundWitnessZod,
-  z56.array(PayloadZodLoose2)
+  z57.array(PayloadZodLoose2)
 ]);
-var isUnsignedHydratedTransaction = zodIsFactory17(UnsignedHydratedTransactionZod);
+var isUnsignedHydratedTransaction = zodIsFactory18(UnsignedHydratedTransactionZod);
 var asUnsignedHydratedTransaction = zodAsFactory18(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
 var toUnsignedHydratedTransaction = zodToFactory17(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z56.tuple([
+var UnsignedHydratedTransactionWithHashMetaZod = z57.tuple([
   WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
-  z56.array(z56.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z57.array(z57.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory17(UnsignedHydratedTransactionWithHashMetaZod);
+var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory18(UnsignedHydratedTransactionWithHashMetaZod);
 var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory18(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
 var toUnsignedHydratedTransactionWithHashMeta = zodToFactory17(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z56.tuple([
+var UnsignedHydratedTransactionWithStorageMetaZod = z57.tuple([
   WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
-  z56.array(z56.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z57.array(z57.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory17(UnsignedHydratedTransactionWithStorageMetaZod);
+var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory18(UnsignedHydratedTransactionWithStorageMetaZod);
 var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory18(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "asUnsignedHydratedTransactionWithStorageMeta"
@@ -1642,25 +1678,25 @@ var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory17(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z56.tuple([
+var SignedHydratedTransactionZod = z57.tuple([
   SignedTransactionBoundWitnessZod,
-  z56.array(PayloadZodLoose2)
+  z57.array(PayloadZodLoose2)
 ]);
-var isSignedHydratedTransaction = zodIsFactory17(SignedHydratedTransactionZod);
+var isSignedHydratedTransaction = zodIsFactory18(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory18(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var toSignedHydratedTransaction = zodToFactory17(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z56.tuple([
+var SignedHydratedTransactionWithHashMetaZod = z57.tuple([
   WithHashMetaZod7(SignedTransactionBoundWitnessZod),
-  z56.array(z56.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z57.array(z57.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isSignedHydratedTransactionWithHashMeta = zodIsFactory17(SignedHydratedTransactionWithHashMetaZod);
+var isSignedHydratedTransactionWithHashMeta = zodIsFactory18(SignedHydratedTransactionWithHashMetaZod);
 var asSignedHydratedTransactionWithHashMeta = zodAsFactory18(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
 var toSignedHydratedTransactionWithHashMeta = zodToFactory17(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z56.tuple([
+var SignedHydratedTransactionWithStorageMetaZod = z57.tuple([
   WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
-  z56.array(z56.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z57.array(z57.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isSignedHydratedTransactionWithStorageMeta = zodIsFactory17(SignedHydratedTransactionWithStorageMetaZod);
+var isSignedHydratedTransactionWithStorageMeta = zodIsFactory18(SignedHydratedTransactionWithStorageMetaZod);
 var asSignedHydratedTransactionWithStorageMeta = zodAsFactory18(
   SignedHydratedTransactionWithStorageMetaZod,
   "asSignedHydratedTransactionWithStorageMeta"
@@ -1674,22 +1710,22 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory17(
 var ELEVATE_OPCODE = "elevate";
 
 // src/modules/protocol-model/model/Permission.ts
-import { z as z57 } from "zod";
-var CaveatTypesZod = z57.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z57.object({
+import { z as z58 } from "zod";
+var CaveatTypesZod = z58.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z58.object({
   type: CaveatTypesZod,
-  value: z57.json()
+  value: z58.json()
 });
-var PermissionZod = z57.object({
-  parentCapability: z57.string(),
+var PermissionZod = z58.object({
+  parentCapability: z58.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z57.string()
+  invoker: z58.string()
 });
-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()
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z58.number().optional() });
+var PermissionRequestZod = z58.record(z58.string(), z58.record(z58.string(), z58.any()));
+var RequestedPermissionZod = z58.object({
+  parentCapability: z58.string(),
+  date: z58.number().optional()
 });
 
 // src/modules/protocol-model/model/rewards.ts
@@ -1704,12 +1740,12 @@ var XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20000000000n, XL1_REWARD
 
 // src/modules/protocol-model/model/RewardsRangeOptions.ts
 import { XyoAddressZod as XyoAddressZod16 } from "@xyo-network/sdk";
-import { z as z58 } from "zod";
-var RewardsRangeOptionsZod = z58.object({
-  positions: z58.array(z58.number()).optional(),
+import { z as z59 } from "zod";
+var RewardsRangeOptionsZod = z59.object({
+  positions: z59.array(z59.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z58.array(StepIdentityZod).optional(),
-  stakers: z58.array(XyoAddressZod16).optional()
+  steps: z59.array(StepIdentityZod).optional(),
+  stakers: z59.array(XyoAddressZod16).optional()
 });
 
 // src/modules/protocol-model/model/RuleActivation.ts
@@ -1751,34 +1787,34 @@ 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 z59 } from "zod";
+import { z as z60 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z59.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z59.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z60.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z60.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-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]);
+var QualifiedSequenceToStringZod = z60.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z60.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z60.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z60.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
 
 // src/modules/protocol-model/model/Stake.ts
 import { HexZod as HexZod7 } from "@ariestools/sdk";
 import { XyoAddressZod as XyoAddressZod17 } from "@xyo-network/sdk";
-import { z as z60 } from "zod";
-var StakeZod = z60.object({
+import { z as z61 } from "zod";
+var StakeZod = z61.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z60.number(),
+  addBlock: z61.number(),
   // the unique id for the stake item
-  id: z60.number(),
+  id: z61.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z60.number(),
+  removeBlock: z61.number(),
   // the address that is being staked
   staked: XyoAddressZod17,
   // the address that owns the stake
   staker: XyoAddressZod17,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z60.number()
+  withdrawBlock: z61.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
@@ -1802,57 +1838,57 @@ var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
 // src/modules/protocol-model/model/SyncStepSummary.ts
 import {
   zodAsFactory as zodAsFactory19,
-  zodIsFactory as zodIsFactory18,
+  zodIsFactory as zodIsFactory19,
   zodToFactory as zodToFactory18
 } from "@ariestools/sdk";
-import { z as z61 } from "zod";
-var SyncStepSummaryMetadataZod = z61.object({
+import { z as z62 } from "zod";
+var SyncStepSummaryMetadataZod = z62.object({
   block: XL1BlockNumberZod,
-  blockCount: z61.int().nonnegative(),
-  bytes: z61.int().nonnegative(),
-  createdAt: z61.string(),
+  blockCount: z62.int().nonnegative(),
+  bytes: z62.int().nonnegative(),
+  createdAt: z62.string(),
   endBlock: XL1BlockNumberZod,
-  relativePath: z61.string(),
+  relativePath: z62.string(),
   startBlock: XL1BlockNumberZod,
-  step: z61.int().nonnegative(),
+  step: z62.int().nonnegative(),
   stepSize: XL1BlockNumberZod,
-  updatedAt: z61.string()
+  updatedAt: z62.string()
 });
-var isSyncStepSummaryMetadata = zodIsFactory18(SyncStepSummaryMetadataZod);
+var isSyncStepSummaryMetadata = zodIsFactory19(SyncStepSummaryMetadataZod);
 var asSyncStepSummaryMetadata = zodAsFactory19(SyncStepSummaryMetadataZod, "asSyncStepSummaryMetadata");
 var toSyncStepSummaryMetadata = zodToFactory18(SyncStepSummaryMetadataZod, "toSyncStepSummaryMetadata");
-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 SyncStepSummaryStatusZod = z62.object({
+  currentBlock: z62.optional(XL1BlockNumberZod),
+  isIndexing: z62.boolean(),
+  nextBoundaries: z62.record(z62.string(), XL1BlockNumberZod),
+  summaries: z62.array(SyncStepSummaryMetadataZod),
+  summaryCount: z62.int().nonnegative()
 });
-var isSyncStepSummaryStatus = zodIsFactory18(SyncStepSummaryStatusZod);
+var isSyncStepSummaryStatus = zodIsFactory19(SyncStepSummaryStatusZod);
 var asSyncStepSummaryStatus = zodAsFactory19(SyncStepSummaryStatusZod, "asSyncStepSummaryStatus");
 var toSyncStepSummaryStatus = zodToFactory18(SyncStepSummaryStatusZod, "toSyncStepSummaryStatus");
-var SyncStepSummaryZod = z61.array(SignedHydratedBlockWithHashMetaZod);
-var isSyncStepSummary = zodIsFactory18(SyncStepSummaryZod);
+var SyncStepSummaryZod = z62.array(SignedHydratedBlockWithHashMetaZod);
+var isSyncStepSummary = zodIsFactory19(SyncStepSummaryZod);
 var asSyncStepSummary = zodAsFactory19(SyncStepSummaryZod, "asSyncStepSummary");
 var toSyncStepSummary = zodToFactory18(SyncStepSummaryZod, "toSyncStepSummary");
 
 // src/modules/protocol-model/model/TimeDomain.ts
-import { z as z62 } from "zod";
-var TimeDomainZod = z62.union([
-  z62.literal("xl1"),
-  z62.literal("epoch"),
-  z62.literal("ethereum")
+import { z as z63 } from "zod";
+var TimeDomainZod = z63.union([
+  z63.literal("xl1"),
+  z63.literal("epoch"),
+  z63.literal("ethereum")
 ]);
 
 // src/modules/protocol-model/model/TransactionInclusion.ts
 import {
   HashZod as HashZod16,
   zodAsFactory as zodAsFactory20,
-  zodIsFactory as zodIsFactory19,
+  zodIsFactory as zodIsFactory20,
   zodToFactory as zodToFactory19
 } from "@ariestools/sdk";
-import { z as z63 } from "zod";
-var TransactionInclusionZod = z63.object({
+import { z as z64 } from "zod";
+var TransactionInclusionZod = z64.object({
   /** Hash of the finalized block containing the transaction. */
   blockHash: HashZod16,
   /** Number of the finalized block containing the transaction. */
@@ -1860,16 +1896,16 @@ var TransactionInclusionZod = z63.object({
   /** Hash of the included transaction. */
   transactionHash: HashZod16,
   /** Zero-based transaction position within the block. */
-  transactionIndex: z63.int().nonnegative()
+  transactionIndex: z64.int().nonnegative()
 });
-var isTransactionInclusion = zodIsFactory19(TransactionInclusionZod);
+var isTransactionInclusion = zodIsFactory20(TransactionInclusionZod);
 var asTransactionInclusion = zodAsFactory20(TransactionInclusionZod, "asTransactionInclusion");
 var toTransactionInclusion = zodToFactory19(TransactionInclusionZod, "toTransactionInclusion");
 
 // src/modules/protocol-model/model/TransferPair.ts
 import { XyoAddressZod as XyoAddressZod18 } from "@xyo-network/sdk";
-import { z as z64 } from "zod";
-var TransferPairZod = z64.tuple([
+import { z as z65 } from "zod";
+var TransferPairZod = z65.tuple([
   XyoAddressZod18,
   XyoAddressZod18
 ]);
@@ -1896,25 +1932,25 @@ import {
   isPayloadOfSchemaType as isPayloadOfSchemaType8,
   PayloadZodOfSchema as PayloadZodOfSchema4
 } from "@xyo-network/sdk";
-import { z as z66 } from "zod/mini";
+import { z as z67 } from "zod/mini";
 
 // src/modules/protocol-model/rejection/RejectionError.ts
 import { HashZod as HashZod17 } from "@ariestools/sdk";
-import { z as z65 } from "zod";
-var RejectionErrorZod = z65.object({
+import { z as z66 } from "zod";
+var RejectionErrorZod = z66.object({
   hash: HashZod17,
-  message: z65.string().optional(),
-  name: z65.string()
+  message: z66.string().optional(),
+  name: z66.string()
 }).loose();
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
 var BlockRejectionSchema = asSchema29("network.xyo.block.rejection", true);
-var BlockRejectionFieldsZod = z66.object({
+var BlockRejectionFieldsZod = z67.object({
   block: HydratedBlockZod,
-  errors: z66.array(RejectionErrorZod),
-  rejector: z66.string()
+  errors: z67.array(RejectionErrorZod),
+  rejector: z67.string()
 });
-var BlockRejectionZod = z66.extend(
+var BlockRejectionZod = z67.extend(
   PayloadZodOfSchema4(BlockRejectionSchema),
   BlockRejectionFieldsZod.shape
 );
@@ -1928,14 +1964,14 @@ import {
   isPayloadOfSchemaType as isPayloadOfSchemaType9,
   PayloadZodOfSchema as PayloadZodOfSchema5
 } from "@xyo-network/sdk";
-import { z as z67 } from "zod/mini";
+import { z as z68 } from "zod/mini";
 var TransactionRejectionSchema = asSchema30("network.xyo.transaction.rejection", true);
-var TransactionRejectionFieldsZod = z67.object({
-  errors: z67.array(RejectionErrorZod),
-  rejector: z67.string(),
+var TransactionRejectionFieldsZod = z68.object({
+  errors: z68.array(RejectionErrorZod),
+  rejector: z68.string(),
   transaction: HydratedTransactionZod
 });
-var TransactionRejectionZod = z67.extend(
+var TransactionRejectionZod = z68.extend(
   PayloadZodOfSchema5(TransactionRejectionSchema),
   TransactionRejectionFieldsZod.shape
 );
@@ -2006,6 +2042,7 @@ export {
   ChainZod,
   ClaimFieldsZod,
   ClaimSchema,
+  ClaimSubjectZod,
   ClaimZod,
   CountZod,
   DefaultProviderMoniker,
@@ -2191,6 +2228,9 @@ export {
   XYO_NETWORK_STAKING_ADDRESS,
   XYO_STEP_REWARD_ADDRESS,
   XYO_ZERO_ADDRESS,
+  Xl1PayloadVersion,
+  Xl1PayloadVersionFieldsZod,
+  Xl1PayloadVersionZod,
   adjudicableRuleId,
   asAttoXL1,
   asBlockBoundWitness,
@@ -2392,6 +2432,7 @@ export {
   isUnsignedTransactionBoundWitnessWithStorageMeta,
   isValidStep,
   isXL1,
+  isXl1PayloadVersionSupported,
   minTransactionFees,
   reportableRuleId,
   ruleActivationStateAt,