@xyo-network/xl1-protocol 5.4.2 → 5.5.1

package/dist/neutral/protocol-model.mjs

@@ -1,12 +1,12 @@
 // src/modules/protocol-model/block/AllowedBlockPayload.ts
-import { zodIsFactory as zodIsFactory7 } from "@ariestools/sdk";
+import { zodIsFactory as zodIsFactory29 } from "@ariestools/sdk";
 import {
   BoundWitnessSchema,
   isHashMeta,
   isSchemaPayload,
   SchemaSchema
 } from "@xyo-network/sdk";
-import { z as z35 } from "zod";
+import { z as z39 } from "zod";
 
 // src/modules/protocol-model/model/PayloadVersion.ts
 import { zodIsFactory } from "@ariestools/sdk";
@@ -17,8 +17,16 @@ var Xl1PayloadVersionFieldsZod = z.object({ $version: z.optional(Xl1PayloadVersi
 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 {
+  HashZod,
+  zodAsFactory,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory
+} from "@ariestools/sdk";
+import {
+  asSchema,
+  PayloadZodOfSchema
+} from "@xyo-network/sdk";
 import { z as z2 } from "zod/mini";
 var ExchangeOutcomeSchema = asSchema("network.xyo.exchange.outcome", true);
 var ExchangeOutcomeFieldsZod = z2.object({
@@ -27,26 +35,30 @@ var ExchangeOutcomeFieldsZod = z2.object({
   /** Settlement result */
   outcome: z2.enum(["fulfilled", "rejected"])
 });
-var isExchangeOutcome = isPayloadOfZodType(
-  ExchangeOutcomeFieldsZod,
-  ExchangeOutcomeSchema
-);
-var asExchangeOutcome = AsObjectFactory.create(isExchangeOutcome);
+var ExchangeOutcomeZod = z2.extend(PayloadZodOfSchema(ExchangeOutcomeSchema), ExchangeOutcomeFieldsZod.shape);
+var isExchangeOutcome = zodIsFactory2(ExchangeOutcomeZod);
+var asExchangeOutcome = zodAsFactory(ExchangeOutcomeZod, "asExchangeOutcome");
+var toExchangeOutcome = zodToFactory(ExchangeOutcomeZod, "toExchangeOutcome");
 
 // src/modules/protocol-model/payload/application/Exchange/ExchangeTerms.ts
-import { AsObjectFactory as AsObjectFactory2, HashZod as HashZod2 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod2,
+  zodAsFactory as zodAsFactory8,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory8
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema2,
-  isPayloadOfZodType as isPayloadOfZodType2,
+  PayloadZodOfSchema as PayloadZodOfSchema2,
   XyoAddressZod as XyoAddressZod2
 } from "@xyo-network/sdk";
 import { z as z11 } from "zod/mini";
 
 // src/modules/protocol-model/transaction/TransactionBoundWitness.ts
 import {
-  zodAsFactory as zodAsFactory6,
-  zodIsFactory as zodIsFactory4,
-  zodToFactory as zodToFactory6
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory7
 } from "@ariestools/sdk";
 import {
   BoundWitnessZod,
@@ -61,7 +73,7 @@ import {
 import { z as z10 } from "zod/mini";
 
 // src/modules/protocol-model/BlockNumber/BlockNumber.ts
-import { zodAsFactory, zodToFactory } from "@ariestools/sdk";
+import { zodAsFactory as zodAsFactory2, zodToFactory as zodToFactory2 } from "@ariestools/sdk";
 import { z as z4 } from "zod";
 
 // src/modules/protocol-model/BlockNumber/Numberish.ts
@@ -71,26 +83,26 @@ var NumberishZod = z3.union([z3.number(), z3.string(), z3.bigint()]).transform((
 // src/modules/protocol-model/BlockNumber/BlockNumber.ts
 var BlockNumberZod = z4.int().nonnegative().transform((v) => v);
 var BlockNumberishZod = NumberishZod.transform((v) => v);
-var asBlockNumber = zodAsFactory(BlockNumberZod, "asBlockNumber");
-var toBlockNumber = zodToFactory(BlockNumberishZod, "toBlockNumber");
+var asBlockNumber = zodAsFactory2(BlockNumberZod, "asBlockNumber");
+var toBlockNumber = zodToFactory2(BlockNumberishZod, "toBlockNumber");
 var BLOCK_NUMBER_ZERO = asBlockNumber(0);
 
 // src/modules/protocol-model/BlockNumber/EthBlockNumber.ts
-import { zodAsFactory as zodAsFactory2, zodToFactory as zodToFactory2 } from "@ariestools/sdk";
+import { zodAsFactory as zodAsFactory3, zodToFactory as zodToFactory3 } from "@ariestools/sdk";
 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");
+var asEthBlockNumber = zodAsFactory3(EthBlockNumberZod, "asEthBlockNumber");
+var toEthBlockNumber = zodToFactory3(EthBlockNumberishZod, "toEthBlockNumber");
 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 { zodAsFactory as zodAsFactory4, zodToFactory as zodToFactory4 } from "@ariestools/sdk";
 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");
+var asXL1BlockNumber = zodAsFactory4(XL1BlockNumberZod, "asXL1BlockNumber");
+var toXL1BlockNumber = zodToFactory4(XL1BlockNumberishZod, "toXL1BlockNumber");
 var XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0);
 
 // src/modules/protocol-model/chain/Chain.ts
@@ -101,23 +113,23 @@ var ChainZod = z7.string().toLowerCase().regex(AddressRegEx).transform((v) => to
 // src/modules/protocol-model/chain/ChainId.ts
 import {
   HexZod,
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory2,
-  zodToFactory as zodToFactory4
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory5
 } from "@ariestools/sdk";
 var ChainIdZod = HexZod;
-var isChainId = zodIsFactory2(ChainIdZod);
-var asChainId = zodAsFactory4(ChainIdZod, "asChainId");
-var toChainId = zodToFactory4(ChainIdZod, "toChainId");
+var isChainId = zodIsFactory3(ChainIdZod);
+var asChainId = zodAsFactory5(ChainIdZod, "asChainId");
+var toChainId = zodToFactory5(ChainIdZod, "toChainId");
 
 // src/modules/protocol-model/transaction/TransactionFees.ts
 import {
   BigIntToJsonZod,
   HexZod as HexZod2,
   JsonToBigIntZod,
-  zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory5
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory6
 } from "@ariestools/sdk";
 import { z as z9 } from "zod/mini";
 
@@ -251,18 +263,18 @@ var TransactionFeesHexZod = z9.object({
   gasPrice: HexZod2,
   priority: HexZod2
 });
-var isTransactionFeesHex = zodIsFactory3(TransactionFeesHexZod);
-var asTransactionFeesHex = zodAsFactory5(TransactionFeesHexZod, "asTransactionFeesHex");
-var toTransactionFeesHex = zodToFactory5(TransactionFeesHexZod, "toTransactionFeesHex");
+var isTransactionFeesHex = zodIsFactory4(TransactionFeesHexZod);
+var asTransactionFeesHex = zodAsFactory6(TransactionFeesHexZod, "asTransactionFeesHex");
+var toTransactionFeesHex = zodToFactory6(TransactionFeesHexZod, "toTransactionFeesHex");
 var TransactionFeesBigIntZod = z9.object({
   base: AttoZod,
   gasLimit: AttoZod,
   gasPrice: AttoZod,
   priority: AttoZod
 });
-var isTransactionFeesBigInt = zodIsFactory3(TransactionFeesBigIntZod);
-var asTransactionFeesBigInt = zodAsFactory5(TransactionFeesBigIntZod, "asTransactionFeesBigInt");
-var toTransactionFeesBigInt = zodToFactory5(TransactionFeesBigIntZod, "toTransactionFeesBigInt");
+var isTransactionFeesBigInt = zodIsFactory4(TransactionFeesBigIntZod);
+var asTransactionFeesBigInt = zodAsFactory6(TransactionFeesBigIntZod, "asTransactionFeesBigInt");
+var toTransactionFeesBigInt = zodToFactory6(TransactionFeesBigIntZod, "toTransactionFeesBigInt");
 var TransactionFeesJsonToBigIntZod = z9.pipe(
   TransactionFeesHexZod,
   z9.transform((val) => ({
@@ -301,62 +313,62 @@ var TransactionBoundWitnessFieldsZod = z10.safeExtend(
 );
 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 isTransactionBoundWitness = zodIsFactory5(TransactionBoundWitnessZod);
+var asTransactionBoundWitness = zodAsFactory7(TransactionBoundWitnessZod, "asTransactionBoundWitness");
+var toTransactionBoundWitness = zodToFactory7(TransactionBoundWitnessZod, "toTransactionBoundWitness");
 var TransactionBoundWitnessWithHashMetaZod = z10.safeExtend(TransactionBoundWitnessZod, HashMetaZod.shape);
-var isTransactionBoundWitnessWithHashMeta = zodIsFactory4(TransactionBoundWitnessWithHashMetaZod);
-var asTransactionBoundWitnessWithHashMeta = zodAsFactory6(TransactionBoundWitnessWithHashMetaZod, "asTransactionBoundWitnessWithHashMeta");
-var toTransactionBoundWitnessWithHashMeta = zodToFactory6(TransactionBoundWitnessWithHashMetaZod, "toTransactionBoundWitnessWithHashMeta");
+var isTransactionBoundWitnessWithHashMeta = zodIsFactory5(TransactionBoundWitnessWithHashMetaZod);
+var asTransactionBoundWitnessWithHashMeta = zodAsFactory7(TransactionBoundWitnessWithHashMetaZod, "asTransactionBoundWitnessWithHashMeta");
+var toTransactionBoundWitnessWithHashMeta = zodToFactory7(TransactionBoundWitnessWithHashMetaZod, "toTransactionBoundWitnessWithHashMeta");
 var TransactionBoundWitnessWithStorageMetaZod = z10.safeExtend(TransactionBoundWitnessZod, StorageMetaZod.shape);
-var isTransactionBoundWitnessWithStorageMeta = zodIsFactory4(TransactionBoundWitnessWithStorageMetaZod);
-var asTransactionBoundWitnessWithStorageMeta = zodAsFactory6(TransactionBoundWitnessWithStorageMetaZod, "asTransactionBoundWitnessWithStorageMeta");
-var toTransactionBoundWitnessWithStorageMeta = zodToFactory6(TransactionBoundWitnessWithStorageMetaZod, "toTransactionBoundWitnessWithStorageMeta");
+var isTransactionBoundWitnessWithStorageMeta = zodIsFactory5(TransactionBoundWitnessWithStorageMetaZod);
+var asTransactionBoundWitnessWithStorageMeta = zodAsFactory7(TransactionBoundWitnessWithStorageMetaZod, "asTransactionBoundWitnessWithStorageMeta");
+var toTransactionBoundWitnessWithStorageMeta = zodToFactory7(TransactionBoundWitnessWithStorageMetaZod, "toTransactionBoundWitnessWithStorageMeta");
 var UnsignedTransactionBoundWitnessZod = z10.safeExtend(UnsignedBoundWitnessZod, transactionBoundWitnessShape);
-var isUnsignedTransactionBoundWitness = zodIsFactory4(UnsignedTransactionBoundWitnessZod);
-var asUnsignedTransactionBoundWitness = zodAsFactory6(UnsignedTransactionBoundWitnessZod, "asUnsignedTransactionBoundWitness");
-var toUnsignedTransactionBoundWitness = zodToFactory6(UnsignedTransactionBoundWitnessZod, "toUnsignedTransactionBoundWitness");
+var isUnsignedTransactionBoundWitness = zodIsFactory5(UnsignedTransactionBoundWitnessZod);
+var asUnsignedTransactionBoundWitness = zodAsFactory7(UnsignedTransactionBoundWitnessZod, "asUnsignedTransactionBoundWitness");
+var toUnsignedTransactionBoundWitness = zodToFactory7(UnsignedTransactionBoundWitnessZod, "toUnsignedTransactionBoundWitness");
 var UnsignedTransactionBoundWitnessWithHashMetaZod = z10.safeExtend(UnsignedTransactionBoundWitnessZod, HashMetaZod.shape);
-var isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory4(UnsignedTransactionBoundWitnessWithHashMetaZod);
-var asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory6(
+var isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory5(UnsignedTransactionBoundWitnessWithHashMetaZod);
+var asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory7(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   "asUnsignedTransactionBoundWitnessWithHashMeta"
 );
-var toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory6(
+var toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory7(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   "toUnsignedTransactionBoundWitnessWithHashMeta"
 );
 var UnsignedTransactionBoundWitnessWithStorageMetaZod = z10.safeExtend(UnsignedTransactionBoundWitnessZod, StorageMetaZod.shape);
-var isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory4(UnsignedTransactionBoundWitnessWithStorageMetaZod);
-var asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory6(
+var isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory5(UnsignedTransactionBoundWitnessWithStorageMetaZod);
+var asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory7(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   "asUnsignedTransactionBoundWitnessWithStorageMeta"
 );
-var toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory6(
+var toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory7(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   "toUnsignedTransactionBoundWitnessWithStorageMeta"
 );
 var SignedTransactionBoundWitnessZod = z10.safeExtend(SignedBoundWitnessZod, transactionBoundWitnessShape);
-var isSignedTransactionBoundWitness = zodIsFactory4(SignedTransactionBoundWitnessZod);
-var asSignedTransactionBoundWitness = zodAsFactory6(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
-var toSignedTransactionBoundWitness = zodToFactory6(SignedTransactionBoundWitnessZod, "toSignedTransactionBoundWitness");
+var isSignedTransactionBoundWitness = zodIsFactory5(SignedTransactionBoundWitnessZod);
+var asSignedTransactionBoundWitness = zodAsFactory7(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
+var toSignedTransactionBoundWitness = zodToFactory7(SignedTransactionBoundWitnessZod, "toSignedTransactionBoundWitness");
 var SignedTransactionBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedTransactionBoundWitnessZod);
-var isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory4(SignedTransactionBoundWitnessWithHashMetaZod);
-var asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory6(
+var isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory5(SignedTransactionBoundWitnessWithHashMetaZod);
+var asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory7(
   SignedTransactionBoundWitnessWithHashMetaZod,
   "asSignedTransactionBoundWitnessWithHashMeta"
 );
-var toSignedTransactionBoundWitnessWithHashMeta = zodToFactory6(
+var toSignedTransactionBoundWitnessWithHashMeta = zodToFactory7(
   SignedTransactionBoundWitnessWithHashMetaZod,
   "toSignedTransactionBoundWitnessWithHashMeta"
 );
 var SignedTransactionBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedTransactionBoundWitnessZod);
-var isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory4(SignedTransactionBoundWitnessWithStorageMetaZod);
-var asSignedTransactionBoundWitnessWithStorageMeta = zodAsFactory6(
+var isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory5(SignedTransactionBoundWitnessWithStorageMetaZod);
+var asSignedTransactionBoundWitnessWithStorageMeta = zodAsFactory7(
   SignedTransactionBoundWitnessWithStorageMetaZod,
   "asSignedTransactionBoundWitnessWithStorageMeta"
 );
-var toSignedTransactionBoundWitnessWithStorageMeta = zodToFactory6(
+var toSignedTransactionBoundWitnessWithStorageMeta = zodToFactory7(
   SignedTransactionBoundWitnessWithStorageMetaZod,
   "toSignedTransactionBoundWitnessWithStorageMeta"
 );
@@ -383,30 +395,42 @@ var ExchangeTermsFieldsZod = z11.extend(
   }),
   BlockDurationZod.shape
 );
-var isExchangeTerms = isPayloadOfZodType2(
-  ExchangeTermsFieldsZod,
-  ExchangeTermsSchema
-);
-var asExchangeTerms = AsObjectFactory2.create(isExchangeTerms);
+var ExchangeTermsZod = z11.extend(PayloadZodOfSchema2(ExchangeTermsSchema), ExchangeTermsFieldsZod.shape);
+var isExchangeTerms = zodIsFactory6(ExchangeTermsZod);
+var asExchangeTerms = zodAsFactory8(ExchangeTermsZod, "asExchangeTerms");
+var toExchangeTerms = zodToFactory8(ExchangeTermsZod, "toExchangeTerms");
 
 // 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 {
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory7,
+  zodToFactory as zodToFactory9
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema3,
+  PayloadZodOfSchema as PayloadZodOfSchema3
+} from "@xyo-network/sdk";
 import { z as z12 } from "zod/mini";
 var PartySecretRevealSchema = asSchema3("network.xyo.exchange.party.secret", true);
 var PartySecretRevealFieldsZod = z12.object({
   /** Random opaque value — the bytes don't matter; what matters is that the party signed them */
   nonce: z12.string()
 });
-var isPartySecretReveal = isPayloadOfZodType3(
-  PartySecretRevealFieldsZod,
-  PartySecretRevealSchema
-);
-var asPartySecretReveal = AsObjectFactory3.create(isPartySecretReveal);
+var PartySecretRevealZod = z12.extend(PayloadZodOfSchema3(PartySecretRevealSchema), PartySecretRevealFieldsZod.shape);
+var isPartySecretReveal = zodIsFactory7(PartySecretRevealZod);
+var asPartySecretReveal = zodAsFactory9(PartySecretRevealZod, "asPartySecretReveal");
+var toPartySecretReveal = zodToFactory9(PartySecretRevealZod, "toPartySecretReveal");
 
 // 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 {
+  zodAsFactory as zodAsFactory10,
+  zodIsFactory as zodIsFactory8,
+  zodToFactory as zodToFactory10
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema4,
+  PayloadZodOfSchema as PayloadZodOfSchema4
+} from "@xyo-network/sdk";
 import { z as z13 } from "zod/mini";
 var InscriptionSchema = asSchema4("network.xyo.ordinal.inscription", true);
 var InscriptionFieldsZod = z13.object({
@@ -415,14 +439,21 @@ var InscriptionFieldsZod = z13.object({
   /** Inscribed content — base64 for binary, raw for text/JSON */
   content: z13.string()
 });
-var isInscription = isPayloadOfZodType4(InscriptionFieldsZod, InscriptionSchema);
-var asInscription = AsObjectFactory4.create(isInscription);
+var InscriptionZod = z13.extend(PayloadZodOfSchema4(InscriptionSchema), InscriptionFieldsZod.shape);
+var isInscription = zodIsFactory8(InscriptionZod);
+var asInscription = zodAsFactory10(InscriptionZod, "asInscription");
+var toInscription = zodToFactory10(InscriptionZod, "toInscription");
 
 // src/modules/protocol-model/payload/application/Ordinal/OrdinalTransfer.ts
-import { AsObjectFactory as AsObjectFactory5, HashZod as HashZod3 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod3,
+  zodAsFactory as zodAsFactory11,
+  zodIsFactory as zodIsFactory9,
+  zodToFactory as zodToFactory11
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema5,
-  isPayloadOfZodType as isPayloadOfZodType5,
+  PayloadZodOfSchema as PayloadZodOfSchema5,
   XyoAddressZod as XyoAddressZod3
 } from "@xyo-network/sdk";
 import { z as z14 } from "zod/mini";
@@ -433,11 +464,10 @@ var OrdinalTransferFieldsZod = z14.object({
   /** Recipient address — declarative content; the current owner is derived structurally */
   to: XyoAddressZod3
 });
-var isOrdinalTransfer = isPayloadOfZodType5(
-  OrdinalTransferFieldsZod,
-  OrdinalTransferSchema
-);
-var asOrdinalTransfer = AsObjectFactory5.create(isOrdinalTransfer);
+var OrdinalTransferZod = z14.extend(PayloadZodOfSchema5(OrdinalTransferSchema), OrdinalTransferFieldsZod.shape);
+var isOrdinalTransfer = zodIsFactory9(OrdinalTransferZod);
+var asOrdinalTransfer = zodAsFactory11(OrdinalTransferZod, "asOrdinalTransfer");
+var toOrdinalTransfer = zodToFactory11(OrdinalTransferZod, "toOrdinalTransfer");
 
 // src/modules/protocol-model/payload/application/Xrc20/Ticker.ts
 import { z as z15 } from "zod/mini";
@@ -448,8 +478,15 @@ 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 {
+  zodAsFactory as zodAsFactory12,
+  zodIsFactory as zodIsFactory10,
+  zodToFactory as zodToFactory12
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema6,
+  PayloadZodOfSchema as PayloadZodOfSchema6
+} from "@xyo-network/sdk";
 import { z as z17 } from "zod/mini";
 var TokenDeploySchema = asSchema6("network.xyo.ordinal.token.deploy", true);
 var TokenDeployFieldsZod = z17.object({
@@ -462,12 +499,21 @@ var TokenDeployFieldsZod = z17.object({
   /** Optional decimals (0–18); defaults to 0 in the indexer */
   decimals: z17.optional(z17.int().check(z17.gte(0), z17.lte(18)))
 });
-var isTokenDeploy = isPayloadOfZodType6(TokenDeployFieldsZod, TokenDeploySchema);
-var asTokenDeploy = AsObjectFactory6.create(isTokenDeploy);
+var TokenDeployZod = z17.extend(PayloadZodOfSchema6(TokenDeploySchema), TokenDeployFieldsZod.shape);
+var isTokenDeploy = zodIsFactory10(TokenDeployZod);
+var asTokenDeploy = zodAsFactory12(TokenDeployZod, "asTokenDeploy");
+var toTokenDeploy = zodToFactory12(TokenDeployZod, "toTokenDeploy");
 
 // 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 {
+  zodAsFactory as zodAsFactory13,
+  zodIsFactory as zodIsFactory11,
+  zodToFactory as zodToFactory13
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema7,
+  PayloadZodOfSchema as PayloadZodOfSchema7
+} from "@xyo-network/sdk";
 import { z as z18 } from "zod/mini";
 var TokenMintSchema = asSchema7("network.xyo.ordinal.token.mint", true);
 var TokenMintFieldsZod = z18.object({
@@ -476,14 +522,20 @@ var TokenMintFieldsZod = z18.object({
   /** Amount minted */
   amt: TokenAmountZod
 });
-var isTokenMint = isPayloadOfZodType7(TokenMintFieldsZod, TokenMintSchema);
-var asTokenMint = AsObjectFactory7.create(isTokenMint);
+var TokenMintZod = z18.extend(PayloadZodOfSchema7(TokenMintSchema), TokenMintFieldsZod.shape);
+var isTokenMint = zodIsFactory11(TokenMintZod);
+var asTokenMint = zodAsFactory13(TokenMintZod, "asTokenMint");
+var toTokenMint = zodToFactory13(TokenMintZod, "toTokenMint");
 
 // src/modules/protocol-model/payload/application/Xrc20/TokenTransfer.ts
-import { AsObjectFactory as AsObjectFactory8 } from "@ariestools/sdk";
+import {
+  zodAsFactory as zodAsFactory14,
+  zodIsFactory as zodIsFactory12,
+  zodToFactory as zodToFactory14
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema8,
-  isPayloadOfZodType as isPayloadOfZodType8,
+  PayloadZodOfSchema as PayloadZodOfSchema8,
   XyoAddressZod as XyoAddressZod4
 } from "@xyo-network/sdk";
 import { z as z19 } from "zod/mini";
@@ -496,15 +548,22 @@ var TokenTransferFieldsZod = z19.object({
   /** Amount transferred */
   amt: TokenAmountZod
 });
-var isTokenTransfer = isPayloadOfZodType8(
-  TokenTransferFieldsZod,
-  TokenTransferSchema
-);
-var asTokenTransfer = AsObjectFactory8.create(isTokenTransfer);
+var TokenTransferZod = z19.extend(PayloadZodOfSchema8(TokenTransferSchema), TokenTransferFieldsZod.shape);
+var isTokenTransfer = zodIsFactory12(TokenTransferZod);
+var asTokenTransfer = zodAsFactory14(TokenTransferZod, "asTokenTransfer");
+var toTokenTransfer = zodToFactory14(TokenTransferZod, "toTokenTransfer");
 
 // 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 {
+  HexZod as HexZod4,
+  zodAsFactory as zodAsFactory15,
+  zodIsFactory as zodIsFactory13,
+  zodToFactory as zodToFactory15
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema9,
+  PayloadZodOfSchema as PayloadZodOfSchema9
+} from "@xyo-network/sdk";
 import { z as z21 } from "zod/mini";
 
 // src/modules/protocol-model/payload/elevatable/Bridge/BridgeDetails.ts
@@ -559,15 +618,21 @@ var BridgeDestinationObservationFieldsZod = z21.extend(BridgeDetailsFieldsZod, {
    */
   destConfirmation: z21.optional(HexZod4).check(z21.describe("Destination chain confirmation"))
 });
-var isBridgeDestinationObservation = isPayloadOfZodType9(
-  BridgeDestinationObservationFieldsZod,
-  BridgeDestinationObservationSchema
-);
-var asBridgeDestinationObservation = AsObjectFactory9.create(isBridgeDestinationObservation);
+var BridgeDestinationObservationZod = z21.extend(PayloadZodOfSchema9(BridgeDestinationObservationSchema), BridgeDestinationObservationFieldsZod.shape);
+var isBridgeDestinationObservation = zodIsFactory13(BridgeDestinationObservationZod);
+var asBridgeDestinationObservation = zodAsFactory15(BridgeDestinationObservationZod, "asBridgeDestinationObservation");
+var toBridgeDestinationObservation = zodToFactory15(BridgeDestinationObservationZod, "toBridgeDestinationObservation");
 
 // 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 {
+  zodAsFactory as zodAsFactory16,
+  zodIsFactory as zodIsFactory14,
+  zodToFactory as zodToFactory16
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema10,
+  PayloadZodOfSchema as PayloadZodOfSchema10
+} from "@xyo-network/sdk";
 import { z as z22 } from "zod/mini";
 var BridgeIntentSchema = asSchema10("network.xyo.chain.bridge.intent", true);
 var BridgeIntentFieldsZod = z22.extend(BridgeDetailsFieldsZod, {
@@ -576,15 +641,22 @@ var BridgeIntentFieldsZod = z22.extend(BridgeDetailsFieldsZod, {
    */
   nonce: z22.string().check(z22.describe("Unique identifier for replay protection"))
 });
-var isBridgeIntent = isPayloadOfZodType10(
-  BridgeIntentFieldsZod,
-  BridgeIntentSchema
-);
-var asBridgeIntent = AsObjectFactory10.create(isBridgeIntent);
+var BridgeIntentZod = z22.extend(PayloadZodOfSchema10(BridgeIntentSchema), BridgeIntentFieldsZod.shape);
+var isBridgeIntent = zodIsFactory14(BridgeIntentZod);
+var asBridgeIntent = zodAsFactory16(BridgeIntentZod, "asBridgeIntent");
+var toBridgeIntent = zodToFactory16(BridgeIntentZod, "toBridgeIntent");
 
 // 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 {
+  HexZod as HexZod5,
+  zodAsFactory as zodAsFactory17,
+  zodIsFactory as zodIsFactory15,
+  zodToFactory as zodToFactory17
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema11,
+  PayloadZodOfSchema as PayloadZodOfSchema11
+} from "@xyo-network/sdk";
 import { z as z23 } from "zod/mini";
 var BridgeSourceObservationSchema = asSchema11("network.xyo.chain.bridge.observation.source", true);
 var BridgeSourceObservationFieldsZod = z23.extend(BridgeDetailsFieldsZod, {
@@ -593,54 +665,67 @@ var BridgeSourceObservationFieldsZod = z23.extend(BridgeDetailsFieldsZod, {
    */
   srcConfirmation: z23.optional(HexZod5).check(z23.describe("Source chain confirmation"))
 });
-var isBridgeSourceObservation = isPayloadOfZodType11(
-  BridgeSourceObservationFieldsZod,
-  BridgeSourceObservationSchema
-);
-var asBridgeSourceObservation = AsObjectFactory11.create(isBridgeSourceObservation);
+var BridgeSourceObservationZod = z23.extend(PayloadZodOfSchema11(BridgeSourceObservationSchema), BridgeSourceObservationFieldsZod.shape);
+var isBridgeSourceObservation = zodIsFactory15(BridgeSourceObservationZod);
+var asBridgeSourceObservation = zodAsFactory17(BridgeSourceObservationZod, "asBridgeSourceObservation");
+var toBridgeSourceObservation = zodToFactory17(BridgeSourceObservationZod, "toBridgeSourceObservation");
 
 // src/modules/protocol-model/payload/elevatable/ChainStakeIntent.ts
-import { AsObjectFactory as AsObjectFactory12 } from "@ariestools/sdk";
+import {
+  zodAsFactory as zodAsFactory18,
+  zodIsFactory as zodIsFactory16,
+  zodToFactory as zodToFactory18
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema12,
-  isPayloadOfSchemaType,
-  isStorageMeta
+  isStorageMeta,
+  PayloadZodOfSchema as PayloadZodOfSchema12,
+  XyoAddressZod as XyoAddressZod5
 } from "@xyo-network/sdk";
+import { z as z24 } from "zod/mini";
 var ChainStakeIntentSchema = asSchema12("network.xyo.chain.stake.intent", true);
-var isChainStakeIntent = (x) => {
-  return isPayloadOfSchemaType(ChainStakeIntentSchema)(x) && asNonNegativeInteger(x.nbf) !== void 0 && asNonNegativeInteger(x.exp) !== void 0;
-};
-var asChainStakeIntent = AsObjectFactory12.create(isChainStakeIntent);
+var ChainStakeIntentFieldsZod = z24.object({
+  /** Block at which the duration ends. */
+  exp: z24.int().check(z24.gte(0)),
+  /** Address treated as the action source. */
+  from: XyoAddressZod5,
+  /** Chain role for which the source address intends to stake. */
+  intent: z24.literal("producer"),
+  /** Block at which the duration starts. */
+  nbf: z24.int().check(z24.gte(0))
+});
+var ChainStakeIntentZod = z24.extend(PayloadZodOfSchema12(ChainStakeIntentSchema), ChainStakeIntentFieldsZod.shape);
+var isChainStakeIntent = zodIsFactory16(ChainStakeIntentZod);
+var asChainStakeIntent = zodAsFactory18(ChainStakeIntentZod, "asChainStakeIntent");
+var toChainStakeIntent = zodToFactory18(ChainStakeIntentZod, "toChainStakeIntent");
 var isChainStakeIntentWithStorageMeta = (x) => {
   return isChainStakeIntent(x) && isStorageMeta(x);
 };
-var asNonNegativeInteger = (num) => {
-  return Number.isSafeInteger(num) && num >= 0 ? num : void 0;
-};
 
 // src/modules/protocol-model/payload/elevatable/Claim.ts
 import {
-  AsObjectFactory as AsObjectFactory13,
   HashZod as HashZod4,
-  zodIsFactory as zodIsFactory5
+  zodAsFactory as zodAsFactory19,
+  zodIsFactory as zodIsFactory17,
+  zodToFactory as zodToFactory19
 } from "@ariestools/sdk";
 import {
   asSchema as asSchema13,
-  isPayloadOfSchemaType as isPayloadOfSchemaType2,
-  PayloadZodOfSchema,
-  XyoAddressZod as XyoAddressZod5
+  isPayloadOfSchemaType,
+  PayloadZodOfSchema as PayloadZodOfSchema13,
+  XyoAddressZod as XyoAddressZod6
 } from "@xyo-network/sdk";
-import { z as z24 } from "zod/mini";
+import { z as z25 } from "zod/mini";
 var ClaimSchema = asSchema13("network.xyo.statement.claim", true);
 var MAX_CLAIM_HASHES = 256;
-var ClaimSubjectZod = z24.union([XyoAddressZod5, HashZod4]);
-var ClaimFieldsZod = z24.object({
+var ClaimSubjectZod = z25.union([XyoAddressZod6, HashZod4]);
+var ClaimFieldsZod = z25.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: z25.array(HashZod4).check(
+    z25.minLength(1),
+    z25.maxLength(MAX_CLAIM_HASHES),
+    z25.refine(
       (hashes) => new Set(hashes).size === hashes.length,
       { error: "duplicate hashes" }
     )
@@ -648,21 +733,22 @@ var ClaimFieldsZod = z24.object({
   /** 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,
+  source: XyoAddressZod6,
   /** This is the thing that the claim is being made about */
   subject: ClaimSubjectZod
 });
-var ClaimZod = z24.extend(PayloadZodOfSchema(ClaimSchema), {
+var ClaimZod = z25.extend(PayloadZodOfSchema13(ClaimSchema), {
   ...ClaimFieldsZod.shape,
   ...Xl1PayloadVersionFieldsZod.shape
 });
-var isClaimOfSchema = isPayloadOfSchemaType2(ClaimSchema);
+var isClaimOfSchema = isPayloadOfSchemaType(ClaimSchema);
 var isClaim = (value) => {
   return isXl1PayloadVersionSupported(value) && isClaimOfSchema(value);
 };
-var isClaimPayload = zodIsFactory5(ClaimZod);
-var asClaim = AsObjectFactory13.create(isClaimPayload);
-var asClaimPayload = AsObjectFactory13.create(isClaimPayload);
+var isClaimPayload = zodIsFactory17(ClaimZod);
+var asClaimPayload = zodAsFactory19(ClaimZod, "asClaimPayload");
+var toClaimPayload = zodToFactory19(ClaimZod, "toClaimPayload");
+var asClaim = asClaimPayload;
 
 // src/modules/protocol-model/payload/elevatable/Executable.ts
 import { isAnyPayload } from "@xyo-network/sdk";
@@ -677,162 +763,244 @@ var asExecutable = (value) => {
 };
 
 // src/modules/protocol-model/payload/elevatable/Hash.ts
-import { AsObjectFactory as AsObjectFactory14 } from "@ariestools/sdk";
-import { asSchema as asSchema14, isPayloadOfSchemaType as isPayloadOfSchemaType3 } from "@xyo-network/sdk";
+import {
+  HashZod as HashZod5,
+  zodAsFactory as zodAsFactory20,
+  zodIsFactory as zodIsFactory18,
+  zodToFactory as zodToFactory20
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema14,
+  isStorageMeta as isStorageMeta2,
+  PayloadZodOfSchema as PayloadZodOfSchema14
+} from "@xyo-network/sdk";
+import { z as z26 } from "zod/mini";
 var HashSchema = asSchema14("network.xyo.hash", true);
-var isHashPayload = isPayloadOfSchemaType3(HashSchema);
-var asHashPayload = AsObjectFactory14.create(isHashPayload);
-var asHashPayloadWithStorageMeta = AsObjectFactory14.create(isHashPayload);
+var HashFieldsZod = z26.object({
+  /** Protocol hash carried by the payload. */
+  hash: HashZod5
+});
+var HashPayloadZod = z26.extend(PayloadZodOfSchema14(HashSchema), HashFieldsZod.shape);
+var isHashPayload = zodIsFactory18(HashPayloadZod);
+var asHashPayload = zodAsFactory20(HashPayloadZod, "asHashPayload");
+var toHashPayload = zodToFactory20(HashPayloadZod, "toHashPayload");
+var isHashPayloadWithStorageMeta = (value) => {
+  return isHashPayload(value) && isStorageMeta2(value);
+};
+var asHashPayloadWithStorageMeta = (value) => {
+  return isHashPayloadWithStorageMeta(value) ? value : void 0;
+};
 
 // src/modules/protocol-model/payload/elevatable/StepComplete.ts
-import { AsObjectFactory as AsObjectFactory15 } from "@ariestools/sdk";
-import { asSchema as asSchema15, isPayloadOfSchemaType as isPayloadOfSchemaType4 } from "@xyo-network/sdk";
+import {
+  HashZod as HashZod6,
+  zodAsFactory as zodAsFactory21,
+  zodIsFactory as zodIsFactory19,
+  zodToFactory as zodToFactory21
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema15,
+  PayloadZodOfSchema as PayloadZodOfSchema15,
+  XyoAddressZod as XyoAddressZod7
+} from "@xyo-network/sdk";
+import { z as z27 } from "zod/mini";
 var StepCompleteSchema = asSchema15("network.xyo.chain.step.complete", true);
-var isStepComplete = isPayloadOfSchemaType4(StepCompleteSchema);
-var asStepComplete = AsObjectFactory15.create(isStepComplete);
+var StepCompleteFieldsZod = z27.object({
+  /** XL1 block number at the step head. */
+  block: z27.number(),
+  /** Address treated as the action source. */
+  from: XyoAddressZod7,
+  /** Hash that identifies the completed step. */
+  hash: HashZod6,
+  /** Number of XL1 blocks represented by the step. */
+  size: z27.number(),
+  /** Reference block number on the external staking system. */
+  stakeBlock: z27.number()
+});
+var StepCompleteZod = z27.extend(PayloadZodOfSchema15(StepCompleteSchema), StepCompleteFieldsZod.shape);
+var isStepComplete = zodIsFactory19(StepCompleteZod);
+var asStepComplete = zodAsFactory21(StepCompleteZod, "asStepComplete");
+var toStepComplete = zodToFactory21(StepCompleteZod, "toStepComplete");
 
 // src/modules/protocol-model/payload/elevatable/Time.ts
-import { AsObjectFactory as AsObjectFactory16, HashZod as HashZod5 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod7,
+  zodAsFactory as zodAsFactory22,
+  zodIsFactory as zodIsFactory20,
+  zodToFactory as zodToFactory22
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema16,
-  isPayloadOfSchemaType as isPayloadOfSchemaType5,
-  PayloadZodOfSchema as PayloadZodOfSchema2
+  isStorageMeta as isStorageMeta3,
+  PayloadZodOfSchema as PayloadZodOfSchema16
 } from "@xyo-network/sdk";
-import { z as z25 } from "zod/mini";
+import { z as z28 } from "zod/mini";
 var TimeSchema = asSchema16("network.xyo.time", true);
-var XL1TimeFieldsZod = z25.object({
+var XL1TimeFieldsZod = z28.object({
   // block number
-  xl1: z25.optional(z25.number()),
+  xl1: z28.optional(z28.number()),
   // block hash
-  xl1Hash: z25.optional(HashZod5)
+  xl1Hash: z28.optional(HashZod7)
 });
-var EthereumTimeFieldsZod = z25.object({
+var EthereumTimeFieldsZod = z28.object({
   // block number
-  ethereum: z25.optional(z25.number()),
+  ethereum: z28.optional(z28.number()),
   // block hash
-  ethereumHash: z25.optional(HashZod5)
+  ethereumHash: z28.optional(HashZod7)
 });
-var EpochTimeFieldsZod = z25.object({
+var MAX_SAFE_EPOCH = 9999999999999;
+var EpochTimeFieldsZod = z28.object({
   // in milliseconds
-  epoch: z25.number()
+  epoch: z28.int().check(z28.gte(0), z28.lte(MAX_SAFE_EPOCH))
 });
-var TimeFieldsZod = z25.extend(
-  z25.extend(z25.extend(XL1TimeFieldsZod, XL1TimeFieldsZod.shape), EthereumTimeFieldsZod.shape),
+var TimeFieldsZod = z28.extend(
+  z28.extend(z28.extend(XL1TimeFieldsZod, XL1TimeFieldsZod.shape), EthereumTimeFieldsZod.shape),
   EpochTimeFieldsZod.shape
 );
-var TimePayloadZod = z25.extend(PayloadZodOfSchema2(TimeSchema), {
+var TimePayloadZod = z28.extend(PayloadZodOfSchema16(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 isXl1PayloadVersionSupported(value) && isTimePayloadOfSchema(value) && isSafeEpoch(value.epoch);
+var isTimePayload = zodIsFactory20(TimePayloadZod);
+var asTimePayload = zodAsFactory22(TimePayloadZod, "asTimePayload");
+var toTimePayload = zodToFactory22(TimePayloadZod, "toTimePayload");
+var isTimePayloadWithStorageMeta = (value) => {
+  return isTimePayload(value) && isStorageMeta3(value);
+};
+var asTimePayloadWithStorageMeta = (value) => {
+  return isTimePayloadWithStorageMeta(value) ? value : void 0;
 };
-var asTimePayload = AsObjectFactory16.create(isTimePayload);
-var asTimePayloadWithStorageMeta = AsObjectFactory16.create(isTimePayload);
 
 // src/modules/protocol-model/payload/slash/SlashAdjudicationPayload.ts
-import { AsObjectFactory as AsObjectFactory17, HashZod as HashZod6 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod8,
+  zodAsFactory as zodAsFactory23,
+  zodIsFactory as zodIsFactory21,
+  zodToFactory as zodToFactory23
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema17,
-  isPayloadOfZodType as isPayloadOfZodType12,
-  XyoAddressZod as XyoAddressZod6
+  PayloadZodOfSchema as PayloadZodOfSchema17,
+  XyoAddressZod as XyoAddressZod8
 } from "@xyo-network/sdk";
-import { z as z26 } from "zod/mini";
+import { z as z29 } from "zod/mini";
 var SlashOutcomes = ["confirmed", "refuted", "indeterminate", "invalid"];
-var SlashOutcomeZod = z26.literal(SlashOutcomes);
+var SlashOutcomeZod = z29.literal(SlashOutcomes);
 var SlashAdjudicationSchema = asSchema17("network.xyo.chain.slash.adjudication", true);
-var SlashAdjudicationFieldsZod = z26.object({
+var SlashAdjudicationFieldsZod = z29.object({
   /** Address credited with the report, required once bounties are paid. */
-  claimant: z26.optional(XyoAddressZod6),
+  claimant: z29.optional(XyoAddressZod8),
   /** Hash of the commitment that won the claim. */
-  claimantCommit: z26.optional(HashZod6),
+  claimantCommit: z29.optional(HashZod8),
   /** Address issuing the adjudication. */
-  from: XyoAddressZod6,
+  from: XyoAddressZod8,
   /** How the request was resolved. */
   outcome: SlashOutcomeZod,
   /** Why, for any outcome other than confirmed. */
-  reason: z26.optional(z26.string()),
+  reason: z29.optional(z29.string()),
   /** Hash of the request being adjudicated. */
-  request: HashZod6
+  request: HashZod8
 });
-var isSlashAdjudication = isPayloadOfZodType12(
-  SlashAdjudicationFieldsZod,
-  SlashAdjudicationSchema
-);
-var asSlashAdjudication = AsObjectFactory17.create(isSlashAdjudication);
+var SlashAdjudicationZod = z29.extend(PayloadZodOfSchema17(SlashAdjudicationSchema), SlashAdjudicationFieldsZod.shape);
+var isSlashAdjudication = zodIsFactory21(SlashAdjudicationZod);
+var asSlashAdjudication = zodAsFactory23(SlashAdjudicationZod, "asSlashAdjudication");
+var toSlashAdjudication = zodToFactory23(SlashAdjudicationZod, "toSlashAdjudication");
 
 // src/modules/protocol-model/payload/slash/SlashChallengePayload.ts
-import { AsObjectFactory as AsObjectFactory18, HashZod as HashZod7 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod9,
+  zodAsFactory as zodAsFactory24,
+  zodIsFactory as zodIsFactory22,
+  zodToFactory as zodToFactory24
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema18,
-  isPayloadOfZodType as isPayloadOfZodType13,
-  XyoAddressZod as XyoAddressZod7
+  PayloadZodOfSchema as PayloadZodOfSchema18,
+  XyoAddressZod as XyoAddressZod9
 } from "@xyo-network/sdk";
-import { z as z27 } from "zod/mini";
+import { z as z30 } from "zod/mini";
 var SlashChallengeSchema = asSchema18("network.xyo.chain.slash.challenge", true);
-var SlashChallengeFieldsZod = z27.object({
+var SlashChallengeFieldsZod = z30.object({
   /** Hashes of the counter-artifacts, carried in accompanying evidence payloads. */
-  evidence: z27.array(HashZod7),
+  evidence: z30.array(HashZod9),
   /** Address filing the challenge. */
-  from: XyoAddressZod7,
+  from: XyoAddressZod9,
   /** Hash of the request being challenged. */
-  request: HashZod7
+  request: HashZod9
 });
-var isSlashChallenge = isPayloadOfZodType13(SlashChallengeFieldsZod, SlashChallengeSchema);
-var asSlashChallenge = AsObjectFactory18.create(isSlashChallenge);
+var SlashChallengeZod = z30.extend(PayloadZodOfSchema18(SlashChallengeSchema), SlashChallengeFieldsZod.shape);
+var isSlashChallenge = zodIsFactory22(SlashChallengeZod);
+var asSlashChallenge = zodAsFactory24(SlashChallengeZod, "asSlashChallenge");
+var toSlashChallenge = zodToFactory24(SlashChallengeZod, "toSlashChallenge");
 
 // src/modules/protocol-model/payload/slash/SlashCommitPayload.ts
-import { AsObjectFactory as AsObjectFactory19, HashZod as HashZod8 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod10,
+  zodAsFactory as zodAsFactory25,
+  zodIsFactory as zodIsFactory23,
+  zodToFactory as zodToFactory25
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema19,
-  isPayloadOfZodType as isPayloadOfZodType14,
-  XyoAddressZod as XyoAddressZod8
+  PayloadZodOfSchema as PayloadZodOfSchema19,
+  XyoAddressZod as XyoAddressZod10
 } from "@xyo-network/sdk";
-import { z as z28 } from "zod/mini";
+import { z as z31 } from "zod/mini";
 var SlashCommitSchema = asSchema19("network.xyo.chain.slash.commit", true);
-var SlashCommitFieldsZod = z28.object({
+var SlashCommitFieldsZod = z31.object({
   /** Hash of the report this commitment reserves. */
-  commitment: HashZod8,
+  commitment: HashZod10,
   /** Address that will file the report. */
-  from: XyoAddressZod8
+  from: XyoAddressZod10
 });
-var isSlashCommit = isPayloadOfZodType14(SlashCommitFieldsZod, SlashCommitSchema);
-var asSlashCommit = AsObjectFactory19.create(isSlashCommit);
+var SlashCommitZod = z31.extend(PayloadZodOfSchema19(SlashCommitSchema), SlashCommitFieldsZod.shape);
+var isSlashCommit = zodIsFactory23(SlashCommitZod);
+var asSlashCommit = zodAsFactory25(SlashCommitZod, "asSlashCommit");
+var toSlashCommit = zodToFactory25(SlashCommitZod, "toSlashCommit");
 
 // src/modules/protocol-model/payload/slash/SlashEvidencePayload.ts
-import { AsObjectFactory as AsObjectFactory20 } from "@ariestools/sdk";
+import {
+  zodAsFactory as zodAsFactory26,
+  zodIsFactory as zodIsFactory24,
+  zodToFactory as zodToFactory26
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema20,
-  isPayloadOfZodType as isPayloadOfZodType15,
-  XyoAddressZod as XyoAddressZod9
+  PayloadZodOfSchema as PayloadZodOfSchema20,
+  XyoAddressZod as XyoAddressZod11
 } from "@xyo-network/sdk";
-import { z as z29 } from "zod/mini";
+import { z as z32 } from "zod/mini";
 var SlashEvidenceSchema = asSchema20("network.xyo.chain.slash.evidence", true);
-var SlashEvidenceFieldsZod = z29.object({
+var SlashEvidenceFieldsZod = z32.object({
   /** The signed artifacts, exactly as they were observed. */
-  artifacts: z29.array(z29.record(z29.string(), z29.unknown())),
+  artifacts: z32.array(z32.record(z32.string(), z32.unknown())),
   /** Address that submitted the evidence. */
-  from: XyoAddressZod9
+  from: XyoAddressZod11
 });
-var isSlashEvidence = isPayloadOfZodType15(SlashEvidenceFieldsZod, SlashEvidenceSchema);
-var asSlashEvidence = AsObjectFactory20.create(isSlashEvidence);
+var SlashEvidenceZod = z32.extend(PayloadZodOfSchema20(SlashEvidenceSchema), SlashEvidenceFieldsZod.shape);
+var isSlashEvidence = zodIsFactory24(SlashEvidenceZod);
+var asSlashEvidence = zodAsFactory26(SlashEvidenceZod, "asSlashEvidence");
+var toSlashEvidence = zodToFactory26(SlashEvidenceZod, "toSlashEvidence");
 
 // src/modules/protocol-model/payload/slash/SlashRequestPayload.ts
-import { AsObjectFactory as AsObjectFactory21, HashZod as HashZod9 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod11,
+  zodAsFactory as zodAsFactory27,
+  zodIsFactory as zodIsFactory25,
+  zodToFactory as zodToFactory27
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema21,
-  isPayloadOfZodType as isPayloadOfZodType16,
-  XyoAddressZod as XyoAddressZod10
+  PayloadZodOfSchema as PayloadZodOfSchema21,
+  XyoAddressZod as XyoAddressZod12
 } from "@xyo-network/sdk";
-import { z as z31 } from "zod/mini";
+import { z as z34 } from "zod/mini";
 
 // src/modules/protocol-model/model/OffenseCode.ts
-import { z as z30 } from "zod/mini";
+import { z as z33 } from "zod/mini";
 var OffenseCodes = [
   "equivocation",
   "invalid-block",
@@ -842,41 +1010,48 @@ var OffenseCodes = [
   "invalid-slash-request",
   "false-attestation"
 ];
-var OffenseCodeZod = z30.literal(OffenseCodes);
+var OffenseCodeZod = z33.literal(OffenseCodes);
 
 // src/modules/protocol-model/payload/slash/SlashRequestPayload.ts
 var SlashRequestSchema = asSchema21("network.xyo.chain.slash.request", true);
-var SlashRequestFieldsZod = z31.object({
+var SlashRequestFieldsZod = z34.object({
   /** Address accused of the offense. */
-  accused: XyoAddressZod10,
+  accused: XyoAddressZod12,
   /** Height the offense occurred at. */
   block: XL1BlockNumberZod,
   /** Catalog version the offense is judged under. */
-  catalog: z31.number().check(z31.multipleOf(1), z31.positive()),
+  catalog: z34.number().check(z34.multipleOf(1), z34.positive()),
   /** Chain the offense occurred on. */
   chain: ChainIdZod,
   /** Hashes of the artifacts proving the offense, carried in accompanying evidence payloads. */
-  evidence: z31.array(HashZod9),
+  evidence: z34.array(HashZod11),
   /** EVM height the claim is judged against, for anchor and eligibility offenses. */
-  evm: z31.optional(z31.number()),
+  evm: z34.optional(z34.number()),
   /** Address filing the report. */
-  from: XyoAddressZod10,
+  from: XyoAddressZod12,
   /** Offense class being alleged. */
   offense: OffenseCodeZod
 });
-var isSlashRequest = isPayloadOfZodType16(SlashRequestFieldsZod, SlashRequestSchema);
-var asSlashRequest = AsObjectFactory21.create(isSlashRequest);
+var SlashRequestZod = z34.extend(PayloadZodOfSchema21(SlashRequestSchema), SlashRequestFieldsZod.shape);
+var isSlashRequest = zodIsFactory25(SlashRequestZod);
+var asSlashRequest = zodAsFactory27(SlashRequestZod, "asSlashRequest");
+var toSlashRequest = zodToFactory27(SlashRequestZod, "toSlashRequest");
 
 // src/modules/protocol-model/payload/StepIdentityPayload.ts
-import { AsObjectFactory as AsObjectFactory22 } from "@ariestools/sdk";
-import { asSchema as asSchema22, isPayloadOfZodType as isPayloadOfZodType17 } from "@xyo-network/sdk";
+import {
+  zodAsFactory as zodAsFactory28,
+  zodIsFactory as zodIsFactory26,
+  zodToFactory as zodToFactory28
+} from "@ariestools/sdk";
+import { asSchema as asSchema22, PayloadZodOfSchema as PayloadZodOfSchema22 } from "@xyo-network/sdk";
+import { z as z36 } from "zod/mini";
 
 // src/modules/protocol-model/Step/StepIdentity.ts
 import { isUndefined } from "@ariestools/sdk";
-import { z as z32 } from "zod";
-var StepIdentityZod = z32.object({
+import { z as z35 } from "zod";
+var StepIdentityZod = z35.object({
   block: XL1BlockNumberZod.describe("The block number at which the step occurs"),
-  step: z32.number().int().nonnegative().describe("The index of the step into the StepSize array")
+  step: z35.number().int().nonnegative().describe("The index of the step into the StepSize array")
 });
 function tryParseInt(value) {
   if (value === "") return void 0;
@@ -943,32 +1118,41 @@ var StepRewardFractions = [
 
 // src/modules/protocol-model/payload/StepIdentityPayload.ts
 var StepIdentitySchema = asSchema22("network.xyo.chain.step.identity", true);
-var isStepIdentityPayload = isPayloadOfZodType17(StepIdentityZod, StepIdentitySchema);
-var asStepIdentityPayload = AsObjectFactory22.create(isStepIdentityPayload);
+var StepIdentityPayloadZod = z36.extend(PayloadZodOfSchema22(StepIdentitySchema), StepIdentityZod.shape);
+var isStepIdentityPayload = zodIsFactory26(StepIdentityPayloadZod);
+var asStepIdentityPayload = zodAsFactory28(StepIdentityPayloadZod, "asStepIdentityPayload");
+var toStepIdentityPayload = zodToFactory28(StepIdentityPayloadZod, "toStepIdentityPayload");
 
 // src/modules/protocol-model/payload/StepWitness.ts
-import { AsObjectFactory as AsObjectFactory23, HashZod as HashZod10 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod12,
+  zodAsFactory as zodAsFactory29,
+  zodIsFactory as zodIsFactory27,
+  zodToFactory as zodToFactory29
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema23,
-  isPayloadOfZodType as isPayloadOfZodType18,
-  XyoAddressZod as XyoAddressZod11
+  PayloadZodOfSchema as PayloadZodOfSchema23,
+  XyoAddressZod as XyoAddressZod13
 } from "@xyo-network/sdk";
-import { z as z33 } from "zod/mini";
+import { z as z37 } from "zod/mini";
 var StepWitnessSchema = asSchema23("network.xyo.chain.validation.step.witness", true);
-var StepWitnessFieldsZod = z33.object({
+var StepWitnessFieldsZod = z37.object({
   /** Hash of the block in which the step hash was observed */
-  blockHash: HashZod10,
+  blockHash: HashZod12,
   /** Block number of the block in which the step hash was observed */
   blockNumber: XL1BlockNumberZod,
   /** The observed step hash — the entry at the step level's index in the block's step_hashes */
-  stepHash: HashZod10,
+  stepHash: HashZod12,
   /** Block-interval size of the observed step level — must be one of StepSizes */
-  stepSize: z33.literal(StepSizes),
+  stepSize: z37.literal(StepSizes),
   /** Address of the observer */
-  witness: XyoAddressZod11
+  witness: XyoAddressZod13
 });
-var isStepWitness = isPayloadOfZodType18(StepWitnessFieldsZod, StepWitnessSchema);
-var asStepWitness = AsObjectFactory23.create(isStepWitness);
+var StepWitnessZod = z37.extend(PayloadZodOfSchema23(StepWitnessSchema), StepWitnessFieldsZod.shape);
+var isStepWitness = zodIsFactory27(StepWitnessZod);
+var asStepWitness = zodAsFactory29(StepWitnessZod, "asStepWitness");
+var toStepWitness = zodToFactory29(StepWitnessZod, "toStepWitness");
 
 // src/modules/protocol-model/transaction/TransactionGasCosts.ts
 var TransactionGasCosts = {
@@ -989,38 +1173,40 @@ var TransactionGasCosts = {
 
 // src/modules/protocol-model/TransferPayload.ts
 import {
-  AsObjectFactory as AsObjectFactory24,
   HexZod as HexZod6,
   JsonObjectZod,
-  zodIsFactory as zodIsFactory6
+  zodAsFactory as zodAsFactory30,
+  zodIsFactory as zodIsFactory28,
+  zodToFactory as zodToFactory30
 } from "@ariestools/sdk";
 import {
   asSchema as asSchema24,
-  isPayloadOfSchemaType as isPayloadOfSchemaType6,
-  PayloadZodOfSchema as PayloadZodOfSchema3,
-  XyoAddressZod as XyoAddressZod12
+  isPayloadOfSchemaType as isPayloadOfSchemaType2,
+  PayloadZodOfSchema as PayloadZodOfSchema24,
+  XyoAddressZod as XyoAddressZod14
 } from "@xyo-network/sdk";
-import { z as z34 } from "zod/mini";
+import { z as z38 } from "zod/mini";
 var TransferSchema = asSchema24("network.xyo.transfer", true);
-var TransferFieldsZod = z34.object({
+var TransferFieldsZod = z38.object({
   // Removed as only transaction have opCodes
   // $opCodes: z.array(z.string()).optional(),
-  context: z34.optional(JsonObjectZod),
-  epoch: z34.number(),
-  from: XyoAddressZod12,
-  transfers: z34.record(XyoAddressZod12, HexZod6)
+  context: z38.optional(JsonObjectZod),
+  epoch: z38.number(),
+  from: XyoAddressZod14,
+  transfers: z38.record(XyoAddressZod14, HexZod6)
 });
-var TransferZod = z34.extend(PayloadZodOfSchema3(TransferSchema), {
+var TransferZod = z38.extend(PayloadZodOfSchema24(TransferSchema), {
   ...TransferFieldsZod.shape,
   ...Xl1PayloadVersionFieldsZod.shape
 });
-var isTransferOfSchema = isPayloadOfSchemaType6(TransferSchema);
+var isTransferOfSchema = isPayloadOfSchemaType2(TransferSchema);
 var isTransfer = (value) => {
   return isXl1PayloadVersionSupported(value) && isTransferOfSchema(value);
 };
-var isTransferPayload = zodIsFactory6(TransferZod);
-var asTransfer = AsObjectFactory24.create(isTransfer);
-var asTransferPayload = AsObjectFactory24.create(isTransferPayload);
+var isTransferPayload = zodIsFactory28(TransferZod);
+var asTransferPayload = zodAsFactory30(TransferZod, "asTransferPayload");
+var toTransferPayload = zodToFactory30(TransferZod, "toTransferPayload");
+var asTransfer = asTransferPayload;
 
 // src/modules/protocol-model/block/AllowedBlockPayload.ts
 var AllowedBlockPayloadSchemas = [
@@ -1042,11 +1228,11 @@ var AllowedBlockPayloadSchemas = [
   TimeSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadSchemaZod = z35.enum(AllowedBlockPayloadSchemas);
-var isAllowedBlockPayloadSchema = zodIsFactory7(AllowedBlockPayloadSchemaZod);
+var AllowedBlockPayloadSchemaZod = z39.enum(AllowedBlockPayloadSchemas);
+var isAllowedBlockPayloadSchema = zodIsFactory29(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);
+  return isTransferPayload(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isClaimPayload(value) || isHashPayload(value) || isSchemaPayload(value) || isSlashAdjudication(value) || isSlashChallenge(value) || isSlashCommit(value) || isSlashEvidence(value) || isSlashRequest(value) || isStepWitness(value) || isStepComplete(value) || isTimePayload(value) || isTransactionBoundWitness(value);
 };
 var isAllowedBlockPayloadWithHashMeta = (value) => {
   return isAllowedBlockPayload(value) && isHashMeta(value);
@@ -1054,23 +1240,23 @@ var isAllowedBlockPayloadWithHashMeta = (value) => {
 
 // src/modules/protocol-model/block/BlockBoundWitness.ts
 import {
-  HashZod as HashZod11,
-  zodAsFactory as zodAsFactory7,
-  zodIsFactory as zodIsFactory8,
-  zodToFactory as zodToFactory7
+  HashZod as HashZod13,
+  zodAsFactory as zodAsFactory31,
+  zodIsFactory as zodIsFactory30,
+  zodToFactory as zodToFactory31
 } from "@ariestools/sdk";
 import {
   BoundWitnessZod as BoundWitnessZod2,
   WithHashMetaZod as WithHashMetaZod2,
   WithStorageMetaZod as WithStorageMetaZod2
 } from "@xyo-network/sdk";
-import { z as z36 } from "zod/mini";
-var BlockBoundWitnessFieldsZod = z36.object({
+import { z as z40 } from "zod/mini";
+var BlockBoundWitnessFieldsZod = z40.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: z36.nullable(HashZod11),
-  protocol: z36.optional(z36.number()),
-  step_hashes: z36.optional(z36.array(HashZod11)),
+  previous: z40.nullable(HashZod13),
+  protocol: z40.optional(z40.number()),
+  step_hashes: z40.optional(z40.array(HashZod13)),
   /**
    * Signed hash of the same-height candidate this block replaces.
    *
@@ -1078,33 +1264,33 @@ var BlockBoundWitnessFieldsZod = z36.object({
    * honest re-proposal from double-signing, and a producer must not be able to add or drop it
    * after the fact.
    */
-  supersedes: z36.optional(HashZod11)
+  supersedes: z40.optional(HashZod13)
 });
-var BlockBoundWitnessMetaZod = z36.object({ ...Xl1PayloadVersionFieldsZod.shape, $epoch: z36.number() });
-var BlockBoundWitnessZod = z36.object({
+var BlockBoundWitnessMetaZod = z40.object({ ...Xl1PayloadVersionFieldsZod.shape, $epoch: z40.number() });
+var BlockBoundWitnessZod = z40.object({
   ...BoundWitnessZod2.shape,
   ...BlockBoundWitnessFieldsZod.shape,
   ...BlockBoundWitnessMetaZod.shape
 });
-var isBlockBoundWitness = zodIsFactory8(BlockBoundWitnessZod);
-var asBlockBoundWitness = zodAsFactory7(BlockBoundWitnessZod, "asBlockBoundWitness");
-var toBlockBoundWitness = zodToFactory7(BlockBoundWitnessZod, "toBlockBoundWitness");
+var isBlockBoundWitness = zodIsFactory30(BlockBoundWitnessZod);
+var asBlockBoundWitness = zodAsFactory31(BlockBoundWitnessZod, "asBlockBoundWitness");
+var toBlockBoundWitness = zodToFactory31(BlockBoundWitnessZod, "toBlockBoundWitness");
 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 isBlockBoundWitnessWithHashMeta = zodIsFactory30(WithHashMetaZod2(BlockBoundWitnessZod));
+var asBlockBoundWitnessWithHashMeta = zodAsFactory31(WithHashMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithHashMeta");
+var toBlockBoundWitnessWithHashMeta = zodToFactory31(WithHashMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithHashMeta");
 var blockBoundWitnessWithStorageMetaZod = WithStorageMetaZod2(BlockBoundWitnessZod);
 var BlockBoundWitnessWithStorageMetaZod = blockBoundWitnessWithStorageMetaZod;
-var isBlockBoundWitnessWithStorageMeta = zodIsFactory8(WithStorageMetaZod2(BlockBoundWitnessZod));
-var asBlockBoundWitnessWithStorageMeta = zodAsFactory7(WithStorageMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithStorageMeta");
-var toBlockBoundWitnessWithStorageMeta = zodToFactory7(WithStorageMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithStorageMeta");
+var isBlockBoundWitnessWithStorageMeta = zodIsFactory30(WithStorageMetaZod2(BlockBoundWitnessZod));
+var asBlockBoundWitnessWithStorageMeta = zodAsFactory31(WithStorageMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithStorageMeta");
+var toBlockBoundWitnessWithStorageMeta = zodToFactory31(WithStorageMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithStorageMeta");
 
 // src/modules/protocol-model/block/HydratedBlock.ts
 import {
-  zodAsFactory as zodAsFactory11,
-  zodIsFactory as zodIsFactory12,
-  zodToFactory as zodToFactory11
+  zodAsFactory as zodAsFactory35,
+  zodIsFactory as zodIsFactory34,
+  zodToFactory as zodToFactory35
 } from "@ariestools/sdk";
 import {
   PayloadZod,
@@ -1112,38 +1298,38 @@ import {
   WithHashMetaZod as WithHashMetaZod4,
   WithStorageMetaZod as WithStorageMetaZod4
 } from "@xyo-network/sdk";
-import { z as z40 } from "zod/mini";
+import { z as z44 } from "zod/mini";
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitness.ts
 import {
-  zodAsFactory as zodAsFactory8,
-  zodIsFactory as zodIsFactory9,
-  zodToFactory as zodToFactory8
+  zodAsFactory as zodAsFactory32,
+  zodIsFactory as zodIsFactory31,
+  zodToFactory as zodToFactory32
 } from "@ariestools/sdk";
 import { SignedBoundWitnessZod as SignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z37 } from "zod/mini";
-var SignedBlockBoundWitnessZod = z37.safeExtend(
-  z37.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z41 } from "zod/mini";
+var SignedBlockBoundWitnessZod = z41.safeExtend(
+  z41.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
-var isSignedBlockBoundWitness = zodIsFactory9(SignedBlockBoundWitnessZod);
-var asSignedBlockBoundWitness = zodAsFactory8(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
-var toSignedBlockBoundWitness = zodToFactory8(SignedBlockBoundWitnessZod, "toSignedBlockBoundWitness");
+var isSignedBlockBoundWitness = zodIsFactory31(SignedBlockBoundWitnessZod);
+var asSignedBlockBoundWitness = zodAsFactory32(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
+var toSignedBlockBoundWitness = zodToFactory32(SignedBlockBoundWitnessZod, "toSignedBlockBoundWitness");
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithHashMeta.ts
 import {
-  zodAsFactory as zodAsFactory9,
-  zodIsFactory as zodIsFactory10,
-  zodToFactory as zodToFactory9
+  zodAsFactory as zodAsFactory33,
+  zodIsFactory as zodIsFactory32,
+  zodToFactory as zodToFactory33
 } from "@ariestools/sdk";
 import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk";
-import { z as z38 } from "zod/mini";
+import { z as z42 } from "zod/mini";
 var SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod3(SignedBlockBoundWitnessZod);
-var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory10(SignedBlockBoundWitnessWithHashMetaZod);
-var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory9(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
-var SignedBlockBoundWitnessWithHashMetaishZod = z38.pipe(
+var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory32(SignedBlockBoundWitnessWithHashMetaZod);
+var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory33(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
+var SignedBlockBoundWitnessWithHashMetaishZod = z42.pipe(
   SignedBlockBoundWitnessZod,
-  z38.transform(async (data) => {
+  z42.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithHashMeta(data)) {
       return data;
     }
@@ -1153,25 +1339,25 @@ var SignedBlockBoundWitnessWithHashMetaishZod = z38.pipe(
     throw new Error("Invalid SignedBlockBoundWitnessWithHashMetaish format");
   })
 );
-var toSignedBlockBoundWitnessWithHashMeta = zodToFactory9(SignedBlockBoundWitnessWithHashMetaZod, "toSignedBlockBoundWitnessWithHashMeta");
+var toSignedBlockBoundWitnessWithHashMeta = zodToFactory33(SignedBlockBoundWitnessWithHashMetaZod, "toSignedBlockBoundWitnessWithHashMeta");
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts
 import {
-  zodAsFactory as zodAsFactory10,
-  zodIsFactory as zodIsFactory11,
-  zodToFactory as zodToFactory10
+  zodAsFactory as zodAsFactory34,
+  zodIsFactory as zodIsFactory33,
+  zodToFactory as zodToFactory34
 } from "@ariestools/sdk";
 import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod3 } from "@xyo-network/sdk";
-import { z as z39 } from "zod/mini";
+import { z as z43 } from "zod/mini";
 var SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod3(SignedBlockBoundWitnessZod);
-var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory11(SignedBlockBoundWitnessWithStorageMetaZod);
-var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory10(
+var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory33(SignedBlockBoundWitnessWithStorageMetaZod);
+var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory34(
   SignedBlockBoundWitnessWithStorageMetaZod,
   "asSignedBlockBoundWitnessWithStorageMeta"
 );
-var SignedBlockBoundWitnessWithStorageMetaishZod = z39.pipe(
+var SignedBlockBoundWitnessWithStorageMetaishZod = z43.pipe(
   SignedBlockBoundWitnessZod,
-  z39.transform(async (data) => {
+  z43.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
       return data;
     }
@@ -1181,134 +1367,148 @@ var SignedBlockBoundWitnessWithStorageMetaishZod = z39.pipe(
     throw new Error("Invalid SignedBlockBoundWitnessWithStorageMetaish format");
   })
 );
-var toSignedBlockBoundWitnessWithStorageMeta = zodToFactory10(
+var toSignedBlockBoundWitnessWithStorageMeta = zodToFactory34(
   SignedBlockBoundWitnessWithStorageMetaishZod,
   "toSignedBlockBoundWitnessWithStorageMeta"
 );
 
 // src/modules/protocol-model/block/HydratedBlock.ts
-var HydratedBlockZod = z40.tuple([
+var HydratedBlockZod = z44.tuple([
   BlockBoundWitnessZod,
-  z40.array(PayloadZodLoose)
+  z44.array(PayloadZodLoose)
 ]);
-var isHydratedBlock = zodIsFactory12(HydratedBlockZod);
-var asHydratedBlock = zodAsFactory11(HydratedBlockZod, "asHydratedBlock");
-var toHydratedBlock = zodToFactory11(HydratedBlockZod, "toHydratedBlock");
-var HydratedBlockWithHashMetaZod = z40.tuple([
+var isHydratedBlock = zodIsFactory34(HydratedBlockZod);
+var asHydratedBlock = zodAsFactory35(HydratedBlockZod, "asHydratedBlock");
+var toHydratedBlock = zodToFactory35(HydratedBlockZod, "toHydratedBlock");
+var HydratedBlockWithHashMetaZod = z44.tuple([
   WithHashMetaZod4(BlockBoundWitnessZod),
-  z40.array(z40.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z44.array(z44.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var isHydratedBlockWithHashMeta = zodIsFactory12(HydratedBlockWithHashMetaZod);
-var asHydratedBlockWithHashMeta = zodAsFactory11(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
-var toHydratedBlockWithHashMeta = zodToFactory11(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
-var HydratedBlockWithStorageMetaZod = z40.tuple([
+var isHydratedBlockWithHashMeta = zodIsFactory34(HydratedBlockWithHashMetaZod);
+var asHydratedBlockWithHashMeta = zodAsFactory35(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
+var toHydratedBlockWithHashMeta = zodToFactory35(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
+var HydratedBlockWithStorageMetaZod = z44.tuple([
   WithStorageMetaZod4(BlockBoundWitnessZod),
-  z40.array(z40.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z44.array(z44.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
-var isHydratedBlockWithStorageMeta = zodIsFactory12(HydratedBlockWithStorageMetaZod);
-var asHydratedBlockWithStorageMeta = zodAsFactory11(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
-var toHydratedBlockWithStorageMeta = zodToFactory11(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
-var SignedHydratedBlockZod = z40.tuple([
+var isHydratedBlockWithStorageMeta = zodIsFactory34(HydratedBlockWithStorageMetaZod);
+var asHydratedBlockWithStorageMeta = zodAsFactory35(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
+var toHydratedBlockWithStorageMeta = zodToFactory35(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
+var SignedHydratedBlockZod = z44.tuple([
   SignedBlockBoundWitnessZod,
-  z40.array(z40.looseObject(PayloadZod.shape))
+  z44.array(z44.looseObject(PayloadZod.shape))
 ]);
-var isSignedHydratedBlock = zodIsFactory12(SignedHydratedBlockZod);
-var asSignedHydratedBlock = zodAsFactory11(SignedHydratedBlockZod, "asSignedHydratedBlock");
-var toSignedHydratedBlock = zodToFactory11(SignedHydratedBlockZod, "toSignedHydratedBlock");
-var SignedHydratedBlockToJsonZod = z40.tuple([
+var isSignedHydratedBlock = zodIsFactory34(SignedHydratedBlockZod);
+var asSignedHydratedBlock = zodAsFactory35(SignedHydratedBlockZod, "asSignedHydratedBlock");
+var toSignedHydratedBlock = zodToFactory35(SignedHydratedBlockZod, "toSignedHydratedBlock");
+var SignedHydratedBlockToJsonZod = z44.tuple([
   SignedBlockBoundWitnessZod,
-  z40.array(z40.looseObject(PayloadZod.shape))
+  z44.array(z44.looseObject(PayloadZod.shape))
 ]);
-var isSignedHydratedBlockToJson = zodIsFactory12(SignedHydratedBlockToJsonZod);
-var asSignedHydratedBlockToJson = zodAsFactory11(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
-var toSignedHydratedBlockToJson = zodToFactory11(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
-var SignedHydratedBlockWithHashMetaZod = z40.tuple([
+var isSignedHydratedBlockToJson = zodIsFactory34(SignedHydratedBlockToJsonZod);
+var asSignedHydratedBlockToJson = zodAsFactory35(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
+var toSignedHydratedBlockToJson = zodToFactory35(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
+var SignedHydratedBlockWithHashMetaZod = z44.tuple([
   WithHashMetaZod4(SignedBlockBoundWitnessZod),
-  z40.array(z40.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z44.array(z44.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var SignedHydratedBlockWithHashMetaishZod = z40.tuple([
-  z40.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
-  z40.array(z40.looseObject(WithHashMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithHashMetaishZod = z44.tuple([
+  z44.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
+  z44.array(z44.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var isSignedHydratedBlockWithHashMeta = zodIsFactory12(SignedHydratedBlockWithHashMetaZod);
-var asSignedHydratedBlockWithHashMeta = zodAsFactory11(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
-var toSignedHydratedBlockWithHashMeta = zodToFactory11(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
-var SignedHydratedBlockWithStorageMetaZod = z40.tuple([
+var isSignedHydratedBlockWithHashMeta = zodIsFactory34(SignedHydratedBlockWithHashMetaZod);
+var asSignedHydratedBlockWithHashMeta = zodAsFactory35(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
+var toSignedHydratedBlockWithHashMeta = zodToFactory35(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
+var SignedHydratedBlockWithStorageMetaZod = z44.tuple([
   WithStorageMetaZod4(SignedBlockBoundWitnessZod),
-  z40.array(z40.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z44.array(z44.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
-var isSignedHydratedBlockWithStorageMeta = zodIsFactory12(SignedHydratedBlockWithStorageMetaZod);
-var asSignedHydratedBlockWithStorageMeta = zodAsFactory11(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
-var toSignedHydratedBlockWithStorageMeta = zodToFactory11(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
-var SignedHydratedBlockWithStorageMetaishZod = z40.tuple([
-  z40.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
-  z40.array(z40.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+var isSignedHydratedBlockWithStorageMeta = zodIsFactory34(SignedHydratedBlockWithStorageMetaZod);
+var asSignedHydratedBlockWithStorageMeta = zodAsFactory35(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
+var toSignedHydratedBlockWithStorageMeta = zodToFactory35(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
+var SignedHydratedBlockWithStorageMetaishZod = z44.tuple([
+  z44.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
+  z44.array(z44.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 
 // src/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.ts
 import {
-  zodAsFactory as zodAsFactory12,
-  zodIsFactory as zodIsFactory13,
-  zodToFactory as zodToFactory12
+  zodAsFactory as zodAsFactory36,
+  zodIsFactory as zodIsFactory35,
+  zodToFactory as zodToFactory36
 } from "@ariestools/sdk";
 import { UnsignedBoundWitnessZod as UnsignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z41 } from "zod/mini";
-var UnsignedBlockBoundWitnessZod = z41.safeExtend(
-  z41.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z45 } from "zod/mini";
+var UnsignedBlockBoundWitnessZod = z45.safeExtend(
+  z45.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
-var isUnsignedBlockBoundWitness = zodIsFactory13(UnsignedBlockBoundWitnessZod);
-var asUnsignedBlockBoundWitness = zodAsFactory12(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
-var toUnsignedBlockBoundWitness = zodToFactory12(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
+var isUnsignedBlockBoundWitness = zodIsFactory35(UnsignedBlockBoundWitnessZod);
+var asUnsignedBlockBoundWitness = zodAsFactory36(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
+var toUnsignedBlockBoundWitness = zodToFactory36(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
 
 // src/modules/protocol-model/evidence/CandidatePairPayload.ts
-import { AsObjectFactory as AsObjectFactory25, HashZod as HashZod12 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod14,
+  zodAsFactory as zodAsFactory37,
+  zodIsFactory as zodIsFactory36,
+  zodToFactory as zodToFactory37
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema25,
-  isPayloadOfZodType as isPayloadOfZodType19,
-  XyoAddressZod as XyoAddressZod13
+  PayloadZodOfSchema as PayloadZodOfSchema25,
+  XyoAddressZod as XyoAddressZod15
 } from "@xyo-network/sdk";
-import { z as z42 } from "zod/mini";
+import { z as z46 } from "zod/mini";
 var CandidatePairSchema = asSchema25("network.xyo.chain.evidence.candidate.pair", true);
-var CandidatePairFieldsZod = z42.object({
+var CandidatePairFieldsZod = z46.object({
   /** Chain both candidates were proposed on */
   chain: ChainIdZod,
   /** Block number both candidates claim */
   height: XL1BlockNumberZod,
   /** Address that signed both candidates */
-  producer: XyoAddressZod13,
+  producer: XyoAddressZod15,
   /** The two candidates' recomputed bound witness data hashes, sorted ascending */
-  subjects: z42.tuple([HashZod12, HashZod12])
+  subjects: z46.tuple([HashZod14, HashZod14])
 });
-var isCandidatePair = isPayloadOfZodType19(CandidatePairFieldsZod, CandidatePairSchema);
-var asCandidatePair = AsObjectFactory25.create(isCandidatePair);
+var CandidatePairZod = z46.extend(PayloadZodOfSchema25(CandidatePairSchema), CandidatePairFieldsZod.shape);
+var isCandidatePair = zodIsFactory36(CandidatePairZod);
+var asCandidatePair = zodAsFactory37(CandidatePairZod, "asCandidatePair");
+var toCandidatePair = zodToFactory37(CandidatePairZod, "toCandidatePair");
 
 // src/modules/protocol-model/evidence/CandidateSeenPayload.ts
-import { AsObjectFactory as AsObjectFactory26, HashZod as HashZod13 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod15,
+  zodAsFactory as zodAsFactory38,
+  zodIsFactory as zodIsFactory37,
+  zodToFactory as zodToFactory38
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema26,
-  isPayloadOfZodType as isPayloadOfZodType20,
-  XyoAddressZod as XyoAddressZod14
+  PayloadZodOfSchema as PayloadZodOfSchema26,
+  XyoAddressZod as XyoAddressZod16
 } from "@xyo-network/sdk";
-import { z as z43 } from "zod/mini";
+import { z as z47 } from "zod/mini";
 var CandidateSeenSchema = asSchema26("network.xyo.chain.evidence.candidate", true);
-var CandidateSeenFieldsZod = z43.object({
+var CandidateSeenFieldsZod = z47.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: z43.optional(HashZod13),
+  previous: z47.optional(HashZod15),
   /** Address that signed the candidate */
-  producer: XyoAddressZod14,
+  producer: XyoAddressZod16,
   /** Recomputed data hash of the candidate's bound witness */
-  subject: HashZod13
+  subject: HashZod15
 });
-var isCandidateSeen = isPayloadOfZodType20(CandidateSeenFieldsZod, CandidateSeenSchema);
-var asCandidateSeen = AsObjectFactory26.create(isCandidateSeen);
+var CandidateSeenZod = z47.extend(PayloadZodOfSchema26(CandidateSeenSchema), CandidateSeenFieldsZod.shape);
+var isCandidateSeen = zodIsFactory37(CandidateSeenZod);
+var asCandidateSeen = zodAsFactory38(CandidateSeenZod, "asCandidateSeen");
+var toCandidateSeen = zodToFactory38(CandidateSeenZod, "toCandidateSeen");
 
 // src/modules/protocol-model/evidence/EvidenceDisposition.ts
-import { z as z44 } from "zod/mini";
+import { z as z48 } from "zod/mini";
 var EvidenceDispositions = [
   "expired",
   "finalized",
@@ -1318,68 +1518,90 @@ var EvidenceDispositions = [
   "malformed",
   "superseded"
 ];
-var EvidenceDispositionZod = z44.literal(EvidenceDispositions);
+var EvidenceDispositionZod = z48.literal(EvidenceDispositions);
 
 // src/modules/protocol-model/evidence/EvidenceNotePayload.ts
-import { AsObjectFactory as AsObjectFactory27, HashZod as HashZod14 } from "@ariestools/sdk";
+import {
+  HashZod as HashZod16,
+  zodAsFactory as zodAsFactory39,
+  zodIsFactory as zodIsFactory38,
+  zodToFactory as zodToFactory39
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema27,
-  isPayloadOfZodType as isPayloadOfZodType21,
-  XyoAddressZod as XyoAddressZod15
+  PayloadZodOfSchema as PayloadZodOfSchema27,
+  XyoAddressZod as XyoAddressZod17
 } from "@xyo-network/sdk";
-import { z as z45 } from "zod/mini";
+import { z as z49 } from "zod/mini";
 var EvidenceNoteSchema = asSchema27("network.xyo.chain.evidence.note", true);
-var EvidenceNoteFieldsZod = z45.object({
+var EvidenceNoteFieldsZod = z49.object({
   /** Hash of the stored bundle payload this note describes */
-  bundle: HashZod14,
+  bundle: HashZod16,
   /** Why the candidate left the pending pool */
   disposition: EvidenceDispositionZod,
   /** Block number of the archived candidate — absent when the bundle was malformed */
-  height: z45.optional(XL1BlockNumberZod),
+  height: z49.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: z45.optional(XyoAddressZod15),
+  producer: z49.optional(XyoAddressZod17),
   /** Recomputed data hash of the archived block's bound witness — the artifact identity evidence references use */
-  subject: HashZod14
+  subject: HashZod16
 });
-var isEvidenceNote = isPayloadOfZodType21(EvidenceNoteFieldsZod, EvidenceNoteSchema);
-var asEvidenceNote = AsObjectFactory27.create(isEvidenceNote);
+var EvidenceNoteZod = z49.extend(PayloadZodOfSchema27(EvidenceNoteSchema), EvidenceNoteFieldsZod.shape);
+var isEvidenceNote = zodIsFactory38(EvidenceNoteZod);
+var asEvidenceNote = zodAsFactory39(EvidenceNoteZod, "asEvidenceNote");
+var toEvidenceNote = zodToFactory39(EvidenceNoteZod, "toEvidenceNote");
 
 // src/modules/protocol-model/fields/BlockNumber.ts
-import { AsObjectFactory as AsObjectFactory28 } from "@ariestools/sdk";
+import {
+  zodAsFactory as zodAsFactory40,
+  zodIsFactory as zodIsFactory39,
+  zodToFactory as zodToFactory40
+} from "@ariestools/sdk";
 import {
   asSchema as asSchema28,
-  isPayloadOfSchemaType as isPayloadOfSchemaType7,
-  isPayloadOfSchemaTypeWithSources
+  isPayloadOfSchemaTypeWithSources,
+  PayloadZodOfSchema as PayloadZodOfSchema28
 } from "@xyo-network/sdk";
+import { z as z50 } from "zod/mini";
 var BlockNumberSchema = asSchema28("network.xyo.chain.block.number", true);
-var isBlockNumberPayload = isPayloadOfSchemaType7(BlockNumberSchema);
-var asBlockNumberPayload = AsObjectFactory28.create(isBlockNumberPayload);
+var BlockNumberFieldsZod = z50.object({
+  /**
+   * The block number
+   */
+  block: XL1BlockNumberZod
+});
+var BlockNumberPayloadZod = z50.extend(PayloadZodOfSchema28(BlockNumberSchema), BlockNumberFieldsZod.shape);
+var isBlockNumberPayload = zodIsFactory39(BlockNumberPayloadZod);
+var asBlockNumberPayload = zodAsFactory40(BlockNumberPayloadZod, "asBlockNumberPayload");
+var toBlockNumberPayload = zodToFactory40(BlockNumberPayloadZod, "toBlockNumberPayload");
 var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
-var asBlockNumberPayloadWithSources = AsObjectFactory28.create(isBlockNumberPayloadWithSources);
+var asBlockNumberPayloadWithSources = (value) => {
+  return isBlockNumberPayload(value) && isBlockNumberPayloadWithSources(value) ? value : void 0;
+};
 
 // src/modules/protocol-model/model/AccountBalance.ts
-import { zodIsFactory as zodIsFactory16 } from "@ariestools/sdk";
+import { zodIsFactory as zodIsFactory42 } from "@ariestools/sdk";
 import { WithHashMetaZod as WithHashMetaZod5 } from "@xyo-network/sdk";
-import { z as z51 } from "zod/mini";
+import { z as z56 } from "zod/mini";
 
 // src/modules/protocol-model/model/ChainQualification.ts
-import { HashZod as HashZod15, zodIsFactory as zodIsFactory15 } from "@ariestools/sdk";
-import { z as z50 } from "zod";
+import { HashZod as HashZod17, zodIsFactory as zodIsFactory41 } from "@ariestools/sdk";
+import { z as z55 } from "zod";
 
 // src/modules/protocol-model/model/BlockRange/BlockRange.ts
 import {
   assertError,
   isDefined,
-  zodAsFactory as zodAsFactory13,
-  zodToFactory as zodToFactory13
+  zodAsFactory as zodAsFactory41,
+  zodToFactory as zodToFactory41
 } from "@ariestools/sdk";
-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");
+import { z as z51 } from "zod";
+var BlockRangeZod = z51.tuple([BlockNumberZod, BlockNumberZod]);
+var BlockRangeishZod = z51.tuple([BlockNumberishZod, BlockNumberishZod]);
+var asBlockRange = zodAsFactory41(BlockRangeZod, "BlockRange");
+var toBlockRange = zodToFactory41(BlockRangeishZod, "BlockRange");
 var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
 function fromBlockNumberKey(key, assert) {
   const [start, end] = key.split("|").map((v) => asBlockNumber(Number(v)));
@@ -1391,14 +1613,14 @@ function fromBlockNumberKey(key, assert) {
 import {
   assertError as assertError2,
   isDefined as isDefined2,
-  zodAsFactory as zodAsFactory14,
-  zodToFactory as zodToFactory14
+  zodAsFactory as zodAsFactory42,
+  zodToFactory as zodToFactory42
 } from "@ariestools/sdk";
-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");
+import { z as z52 } from "zod";
+var EthBlockRangeZod = z52.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var EthBlockRangeishZod = z52.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
+var asEthBlockRange = zodAsFactory42(EthBlockRangeZod, "EthBlockRange");
+var toEthBlockRange = zodToFactory42(EthBlockRangeishZod, "EthBlockRange");
 var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
 function fromEthBlockNumberKey(key, assert) {
   const [start, end] = key.split("|").map((v) => asEthBlockNumber(Number(v)));
@@ -1408,28 +1630,28 @@ function fromEthBlockNumberKey(key, assert) {
 
 // src/modules/protocol-model/model/BlockRange/Range.ts
 import {
-  zodAsFactory as zodAsFactory15,
-  zodIsFactory as zodIsFactory14,
-  zodToFactory as zodToFactory15
+  zodAsFactory as zodAsFactory43,
+  zodIsFactory as zodIsFactory40,
+  zodToFactory as zodToFactory43
 } from "@ariestools/sdk";
-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");
+import { z as z53 } from "zod";
+var RangeZod = z53.tuple([z53.number(), z53.number()]);
+var isRange = zodIsFactory40(RangeZod);
+var asRange = zodAsFactory43(RangeZod, "Range");
+var toRange = zodToFactory43(RangeZod, "Range");
 
 // src/modules/protocol-model/model/BlockRange/xl1BlockRange.ts
 import {
   assertError as assertError3,
   isDefined as isDefined3,
-  zodAsFactory as zodAsFactory16,
-  zodToFactory as zodToFactory16
+  zodAsFactory as zodAsFactory44,
+  zodToFactory as zodToFactory44
 } from "@ariestools/sdk";
-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");
+import { z as z54 } from "zod";
+var XL1BlockRangeZod = z54.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var XL1BlockRangeishZod = z54.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
+var asXL1BlockRange = zodAsFactory44(XL1BlockRangeZod, "XL1BlockRange");
+var toXL1BlockRange = zodToFactory44(XL1BlockRangeishZod, "XL1BlockRange");
 var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
 function fromXL1BlockNumberKey(key, assert) {
   const [start, end] = key.split("|").map((v) => asXL1BlockNumber(Number(v)));
@@ -1438,33 +1660,33 @@ function fromXL1BlockNumberKey(key, assert) {
 }
 
 // src/modules/protocol-model/model/ChainQualification.ts
-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 ChainQualificationZod = z55.object({ head: HashZod17, range: XL1BlockRangeZod });
+var isChainQualification = zodIsFactory41(ChainQualificationZod);
+var ChainQualifiedRangeConfigZod = z55.object({ range: XL1BlockRangeZod });
+var isChainQualifiedRangeConfig = zodIsFactory41(ChainQualifiedRangeConfigZod);
+var ChainQualifiedHeadConfigZod = z55.object({ head: HashZod17 });
+var isChainQualifiedHeadConfig = zodIsFactory41(ChainQualifiedHeadConfigZod);
+var ChainQualifiedConfigZod = z55.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z55.object({})]);
+var isChainQualifiedConfig = zodIsFactory41(ChainQualifiedConfigZod);
 var ExtendChainQualifiedConfigZod = ((zodType) => {
-  return z50.union([
+  return z55.union([
     ChainQualifiedRangeConfigZod.extend(zodType),
     ChainQualifiedHeadConfigZod.extend(zodType),
     zodType
   ]);
 });
 var ChainQualifiedZod = (zodType) => {
-  return z50.tuple([zodType, ChainQualificationZod]);
+  return z55.tuple([zodType, ChainQualificationZod]);
 };
 
 // src/modules/protocol-model/model/AccountBalance.ts
-var AccountBalanceHistoryItemZod = z51.tuple([
+var AccountBalanceHistoryItemZod = z56.tuple([
   WithHashMetaZod5(BlockBoundWitnessZod),
-  z51.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
+  z56.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
   WithHashMetaZod5(TransferZod)
 ]);
 var AccountBalanceConfigZod = ChainQualifiedConfigZod;
-var isAccountBalanceConfig = zodIsFactory16(AccountBalanceConfigZod);
+var isAccountBalanceConfig = zodIsFactory42(AccountBalanceConfigZod);
 var AccountBalanceViewerMoniker = "AccountBalanceViewer";
 
 // src/modules/protocol-model/model/addresses.ts
@@ -1479,51 +1701,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 z52 } from "zod";
+import { z as z57 } from "zod";
 function base64Encode(u8) {
   return u8.toBase64();
 }
 function base64Decode(b64) {
   return Uint8Array.fromBase64(b64);
 }
-var ArrayBufferToJsonZod = z52.instanceof(ArrayBuffer).transform((x) => {
+var ArrayBufferToJsonZod = z57.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
 });
-var JsonToArrayBufferZod = z52.string().transform((x) => {
+var JsonToArrayBufferZod = z57.string().transform((x) => {
   const u8 = base64Decode(x);
   return u8.buffer;
 });
 
 // src/modules/protocol-model/model/BlockRate.ts
-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()
+import { zodAsFactory as zodAsFactory45, zodIsFactory as zodIsFactory43 } from "@ariestools/sdk";
+import { z as z58 } from "zod";
+var TimeDurationsZod = z58.object({
+  millis: z58.number().nonnegative(),
+  seconds: z58.number().nonnegative(),
+  minutes: z58.number().nonnegative(),
+  hours: z58.number().nonnegative(),
+  days: z58.number().nonnegative(),
+  weeks: z58.number().nonnegative()
 });
-var isTimeDurations = zodIsFactory17(TimeDurationsZod);
-var asTimeDurations = zodAsFactory17(TimeDurationsZod, "asTimeDurations");
-var toTimeDurations = zodAsFactory17(TimeDurationsZod, "toTimeDurations");
-var BlockRateZod = z53.object({
+var isTimeDurations = zodIsFactory43(TimeDurationsZod);
+var asTimeDurations = zodAsFactory45(TimeDurationsZod, "asTimeDurations");
+var toTimeDurations = zodAsFactory45(TimeDurationsZod, "toTimeDurations");
+var BlockRateZod = z58.object({
   range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
-  rate: z53.number().nonnegative().describe("rate of blocks per specified time unit"),
+  rate: z58.number().nonnegative().describe("rate of blocks per specified time unit"),
   timeUnit: TimeDurationsZod.keyof().describe("the unit of time for the rate and timePerBlock"),
-  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")
+  span: z58.int().nonnegative().describe("number of blocks the rate was calculated over"),
+  timeDifference: z58.number().nonnegative().describe("time difference from start and end block"),
+  timePerBlock: z58.number().nonnegative().describe("average time per block for the given range")
 });
-var isBlockRate = zodIsFactory17(BlockRateZod);
-var asBlockRate = zodAsFactory17(BlockRateZod, "asBlockRate");
-var toBlockRate = zodAsFactory17(BlockRateZod, "toBlockRate");
-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({
+var isBlockRate = zodIsFactory43(BlockRateZod);
+var asBlockRate = zodAsFactory45(BlockRateZod, "asBlockRate");
+var toBlockRate = zodAsFactory45(BlockRateZod, "toBlockRate");
+var CountZod = z58.int().nonnegative().describe("A non-negative integer count");
+var StepIndexZod = z58.int().min(0).max(StepSizes.length - 1).describe("A non-negative integer step index");
+var timeUnitSchema = z58.number().positive();
+var TimeConfigZod = z58.object({
   minutes: timeUnitSchema.optional(),
   hours: timeUnitSchema.optional(),
   days: timeUnitSchema.optional(),
@@ -1531,33 +1753,33 @@ var TimeConfigZod = z53.object({
   months: timeUnitSchema.optional(),
   years: timeUnitSchema.optional()
 }).describe("Time configuration with optional time units");
-var isTimeConfig = zodIsFactory17(TimeConfigZod);
-var asTimeConfig = zodAsFactory17(TimeConfigZod, "asTimeConfig");
-var toTimeConfig = zodAsFactory17(TimeConfigZod, "toTimeConfig");
-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 })
+var isTimeConfig = zodIsFactory43(TimeConfigZod);
+var asTimeConfig = zodAsFactory45(TimeConfigZod, "asTimeConfig");
+var toTimeConfig = zodAsFactory45(TimeConfigZod, "toTimeConfig");
+var SingleTimeConfigZod = z58.union([
+  z58.object({ minutes: timeUnitSchema }),
+  z58.object({ hours: timeUnitSchema }),
+  z58.object({ days: timeUnitSchema }),
+  z58.object({ weeks: timeUnitSchema }),
+  z58.object({ months: timeUnitSchema }),
+  z58.object({ years: timeUnitSchema })
 ]).describe("Time configuration with exactly one time unit");
-var isSingleTimeConfig = zodIsFactory17(SingleTimeConfigZod);
-var asSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "asSingleTimeConfig");
-var toSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "toSingleTimeConfig");
+var isSingleTimeConfig = zodIsFactory43(SingleTimeConfigZod);
+var asSingleTimeConfig = zodAsFactory45(SingleTimeConfigZod, "asSingleTimeConfig");
+var toSingleTimeConfig = zodAsFactory45(SingleTimeConfigZod, "toSingleTimeConfig");
 
 // src/modules/protocol-model/model/Context/BaseContext.zod.ts
-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))
+import { z as z59 } from "zod";
+var CachesZod = z59.record(
+  z59.string(),
+  z59.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
 );
-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({
+var SingletonsZod = z59.record(z59.union([z59.string(), z59.symbol()]), z59.unknown());
+var LoggerZod = z59.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
+var MeterProviderZod = z59.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
+var TracerProviderZod = z59.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
+var TimeBudgetLimitZod = z59.number();
+var BaseContextZod = z59.object({
   caches: CachesZod.optional(),
   logger: LoggerZod.optional(),
   meterProvider: MeterProviderZod.optional(),
@@ -1567,24 +1789,24 @@ var BaseContextZod = z54.object({
 });
 
 // src/modules/protocol-model/model/Context/BlockContext.zod.ts
-import z55 from "zod";
+import z60 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: z55.custom((val) => val != null && typeof val === "object" && "get" in val) }
+  { chainMap: z60.custom((val) => val != null && typeof val === "object" && "get" in val) }
 );
 var BlockContextWriteZod = CachingContextZod.extend(
-  { chainMap: z55.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
+  { chainMap: z60.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 z56 from "zod";
-var HeadContextBaseZod = z56.object(
+import z61 from "zod";
+var HeadContextBaseZod = z61.object(
   { head: WithHashMetaZod6(BlockBoundWitnessZod) }
 );
 var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
@@ -1619,9 +1841,9 @@ var defaultTransactionFees = {
 
 // src/modules/protocol-model/model/HydratedTransaction.ts
 import {
-  zodAsFactory as zodAsFactory18,
-  zodIsFactory as zodIsFactory18,
-  zodToFactory as zodToFactory17
+  zodAsFactory as zodAsFactory46,
+  zodIsFactory as zodIsFactory44,
+  zodToFactory as zodToFactory45
 } from "@ariestools/sdk";
 import {
   PayloadZod as PayloadZod2,
@@ -1629,79 +1851,79 @@ import {
   WithHashMetaZod as WithHashMetaZod7,
   WithStorageMetaZod as WithStorageMetaZod5
 } from "@xyo-network/sdk";
-import { z as z57 } from "zod/mini";
-var HydratedTransactionZod = z57.tuple([
+import { z as z62 } from "zod/mini";
+var HydratedTransactionZod = z62.tuple([
   TransactionBoundWitnessZod,
-  z57.array(PayloadZodLoose2)
+  z62.array(PayloadZodLoose2)
 ]);
-var isHydratedTransaction = zodIsFactory18(HydratedTransactionZod);
-var asHydratedTransaction = zodAsFactory18(HydratedTransactionZod, "asHydratedTransaction");
-var toHydratedTransaction = zodToFactory17(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z57.tuple([
+var isHydratedTransaction = zodIsFactory44(HydratedTransactionZod);
+var asHydratedTransaction = zodAsFactory46(HydratedTransactionZod, "asHydratedTransaction");
+var toHydratedTransaction = zodToFactory45(HydratedTransactionZod, "toHydratedTransaction");
+var HydratedTransactionWithHashMetaZod = z62.tuple([
   WithHashMetaZod7(TransactionBoundWitnessZod),
-  z57.array(z57.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z62.array(z62.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isHydratedTransactionWithHashMeta = zodIsFactory18(HydratedTransactionWithHashMetaZod);
-var asHydratedTransactionWithHashMeta = zodAsFactory18(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
-var toHydratedTransactionWithHashMeta = zodToFactory17(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z57.tuple([
+var isHydratedTransactionWithHashMeta = zodIsFactory44(HydratedTransactionWithHashMetaZod);
+var asHydratedTransactionWithHashMeta = zodAsFactory46(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
+var toHydratedTransactionWithHashMeta = zodToFactory45(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
+var HydratedTransactionWithStorageMetaZod = z62.tuple([
   WithStorageMetaZod5(TransactionBoundWitnessZod),
-  z57.array(z57.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z62.array(z62.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isHydratedTransactionWithStorageMeta = zodIsFactory18(HydratedTransactionWithStorageMetaZod);
-var asHydratedTransactionWithStorageMeta = zodAsFactory18(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
-var toHydratedTransactionWithStorageMeta = zodToFactory17(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z57.tuple([
+var isHydratedTransactionWithStorageMeta = zodIsFactory44(HydratedTransactionWithStorageMetaZod);
+var asHydratedTransactionWithStorageMeta = zodAsFactory46(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
+var toHydratedTransactionWithStorageMeta = zodToFactory45(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
+var UnsignedHydratedTransactionZod = z62.tuple([
   UnsignedTransactionBoundWitnessZod,
-  z57.array(PayloadZodLoose2)
+  z62.array(PayloadZodLoose2)
 ]);
-var isUnsignedHydratedTransaction = zodIsFactory18(UnsignedHydratedTransactionZod);
-var asUnsignedHydratedTransaction = zodAsFactory18(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
-var toUnsignedHydratedTransaction = zodToFactory17(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z57.tuple([
+var isUnsignedHydratedTransaction = zodIsFactory44(UnsignedHydratedTransactionZod);
+var asUnsignedHydratedTransaction = zodAsFactory46(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
+var toUnsignedHydratedTransaction = zodToFactory45(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
+var UnsignedHydratedTransactionWithHashMetaZod = z62.tuple([
   WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
-  z57.array(z57.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z62.array(z62.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory18(UnsignedHydratedTransactionWithHashMetaZod);
-var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory18(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
-var toUnsignedHydratedTransactionWithHashMeta = zodToFactory17(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z57.tuple([
+var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory44(UnsignedHydratedTransactionWithHashMetaZod);
+var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory46(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
+var toUnsignedHydratedTransactionWithHashMeta = zodToFactory45(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
+var UnsignedHydratedTransactionWithStorageMetaZod = z62.tuple([
   WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
-  z57.array(z57.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z62.array(z62.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory18(UnsignedHydratedTransactionWithStorageMetaZod);
-var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory18(
+var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory44(UnsignedHydratedTransactionWithStorageMetaZod);
+var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory46(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "asUnsignedHydratedTransactionWithStorageMeta"
 );
-var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory17(
+var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory45(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z57.tuple([
+var SignedHydratedTransactionZod = z62.tuple([
   SignedTransactionBoundWitnessZod,
-  z57.array(PayloadZodLoose2)
+  z62.array(PayloadZodLoose2)
 ]);
-var isSignedHydratedTransaction = zodIsFactory18(SignedHydratedTransactionZod);
-var asSignedHydratedTransaction = zodAsFactory18(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
-var toSignedHydratedTransaction = zodToFactory17(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z57.tuple([
+var isSignedHydratedTransaction = zodIsFactory44(SignedHydratedTransactionZod);
+var asSignedHydratedTransaction = zodAsFactory46(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
+var toSignedHydratedTransaction = zodToFactory45(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
+var SignedHydratedTransactionWithHashMetaZod = z62.tuple([
   WithHashMetaZod7(SignedTransactionBoundWitnessZod),
-  z57.array(z57.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z62.array(z62.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isSignedHydratedTransactionWithHashMeta = zodIsFactory18(SignedHydratedTransactionWithHashMetaZod);
-var asSignedHydratedTransactionWithHashMeta = zodAsFactory18(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
-var toSignedHydratedTransactionWithHashMeta = zodToFactory17(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z57.tuple([
+var isSignedHydratedTransactionWithHashMeta = zodIsFactory44(SignedHydratedTransactionWithHashMetaZod);
+var asSignedHydratedTransactionWithHashMeta = zodAsFactory46(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
+var toSignedHydratedTransactionWithHashMeta = zodToFactory45(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
+var SignedHydratedTransactionWithStorageMetaZod = z62.tuple([
   WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
-  z57.array(z57.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z62.array(z62.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isSignedHydratedTransactionWithStorageMeta = zodIsFactory18(SignedHydratedTransactionWithStorageMetaZod);
-var asSignedHydratedTransactionWithStorageMeta = zodAsFactory18(
+var isSignedHydratedTransactionWithStorageMeta = zodIsFactory44(SignedHydratedTransactionWithStorageMetaZod);
+var asSignedHydratedTransactionWithStorageMeta = zodAsFactory46(
   SignedHydratedTransactionWithStorageMetaZod,
   "asSignedHydratedTransactionWithStorageMeta"
 );
-var toSignedHydratedTransactionWithStorageMeta = zodToFactory17(
+var toSignedHydratedTransactionWithStorageMeta = zodToFactory45(
   SignedHydratedTransactionWithStorageMetaZod,
   "toSignedHydratedTransactionWithStorageMeta"
 );
@@ -1710,22 +1932,22 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory17(
 var ELEVATE_OPCODE = "elevate";
 
 // src/modules/protocol-model/model/Permission.ts
-import { z as z58 } from "zod";
-var CaveatTypesZod = z58.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z58.object({
+import { z as z63 } from "zod";
+var CaveatTypesZod = z63.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z63.object({
   type: CaveatTypesZod,
-  value: z58.json()
+  value: z63.json()
 });
-var PermissionZod = z58.object({
-  parentCapability: z58.string(),
+var PermissionZod = z63.object({
+  parentCapability: z63.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z58.string()
+  invoker: z63.string()
 });
-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()
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z63.number().optional() });
+var PermissionRequestZod = z63.record(z63.string(), z63.record(z63.string(), z63.any()));
+var RequestedPermissionZod = z63.object({
+  parentCapability: z63.string(),
+  date: z63.number().optional()
 });
 
 // src/modules/protocol-model/model/rewards.ts
@@ -1739,13 +1961,13 @@ var XL1_REWARDS_MIN_BLOCK_REWARD = asAttoXL1(toFixedPoint(10n, XL1_REWARDS_PLACE
 var XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20000000000n, XL1_REWARDS_PLACES));
 
 // src/modules/protocol-model/model/RewardsRangeOptions.ts
-import { XyoAddressZod as XyoAddressZod16 } from "@xyo-network/sdk";
-import { z as z59 } from "zod";
-var RewardsRangeOptionsZod = z59.object({
-  positions: z59.array(z59.number()).optional(),
+import { XyoAddressZod as XyoAddressZod18 } from "@xyo-network/sdk";
+import { z as z64 } from "zod";
+var RewardsRangeOptionsZod = z64.object({
+  positions: z64.array(z64.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z59.array(StepIdentityZod).optional(),
-  stakers: z59.array(XyoAddressZod16).optional()
+  steps: z64.array(StepIdentityZod).optional(),
+  stakers: z64.array(XyoAddressZod18).optional()
 });
 
 // src/modules/protocol-model/model/RuleActivation.ts
@@ -1787,42 +2009,42 @@ function isRuleObservedAt(params, ruleId, height) {
 // src/modules/protocol-model/model/Sequence.ts
 import { HexRegExMinMax, toHex } from "@ariestools/sdk";
 import { SequenceConstants } from "@xyo-network/sdk";
-import { z as z60 } from "zod";
+import { z as z65 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z60.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z60.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z65.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z65.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-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]);
+var QualifiedSequenceToStringZod = z65.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z65.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z65.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z65.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 z61 } from "zod";
-var StakeZod = z61.object({
+import { XyoAddressZod as XyoAddressZod19 } from "@xyo-network/sdk";
+import { z as z66 } from "zod";
+var StakeZod = z66.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z61.number(),
+  addBlock: z66.number(),
   // the unique id for the stake item
-  id: z61.number(),
+  id: z66.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z61.number(),
+  removeBlock: z66.number(),
   // the address that is being staked
-  staked: XyoAddressZod17,
+  staked: XyoAddressZod19,
   // the address that owns the stake
-  staker: XyoAddressZod17,
+  staker: XyoAddressZod19,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z61.number()
+  withdrawBlock: z66.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
   amount: BigIntToJsonZod2.parse(val.amount),
   id: val.id,
   removeBlock: val.removeBlock,
-  staked: XyoAddressZod17.parse(val.staked),
-  staker: XyoAddressZod17.parse(val.staker),
+  staked: XyoAddressZod19.parse(val.staked),
+  staker: XyoAddressZod19.parse(val.staker),
   withdrawBlock: val.withdrawBlock
 }));
 var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
@@ -1837,77 +2059,77 @@ var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
 
 // src/modules/protocol-model/model/SyncStepSummary.ts
 import {
-  zodAsFactory as zodAsFactory19,
-  zodIsFactory as zodIsFactory19,
-  zodToFactory as zodToFactory18
+  zodAsFactory as zodAsFactory47,
+  zodIsFactory as zodIsFactory45,
+  zodToFactory as zodToFactory46
 } from "@ariestools/sdk";
-import { z as z62 } from "zod";
-var SyncStepSummaryMetadataZod = z62.object({
+import { z as z67 } from "zod";
+var SyncStepSummaryMetadataZod = z67.object({
   block: XL1BlockNumberZod,
-  blockCount: z62.int().nonnegative(),
-  bytes: z62.int().nonnegative(),
-  createdAt: z62.string(),
+  blockCount: z67.int().nonnegative(),
+  bytes: z67.int().nonnegative(),
+  createdAt: z67.string(),
   endBlock: XL1BlockNumberZod,
-  relativePath: z62.string(),
+  relativePath: z67.string(),
   startBlock: XL1BlockNumberZod,
-  step: z62.int().nonnegative(),
+  step: z67.int().nonnegative(),
   stepSize: XL1BlockNumberZod,
-  updatedAt: z62.string()
+  updatedAt: z67.string()
 });
-var isSyncStepSummaryMetadata = zodIsFactory19(SyncStepSummaryMetadataZod);
-var asSyncStepSummaryMetadata = zodAsFactory19(SyncStepSummaryMetadataZod, "asSyncStepSummaryMetadata");
-var toSyncStepSummaryMetadata = zodToFactory18(SyncStepSummaryMetadataZod, "toSyncStepSummaryMetadata");
-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 isSyncStepSummaryMetadata = zodIsFactory45(SyncStepSummaryMetadataZod);
+var asSyncStepSummaryMetadata = zodAsFactory47(SyncStepSummaryMetadataZod, "asSyncStepSummaryMetadata");
+var toSyncStepSummaryMetadata = zodToFactory46(SyncStepSummaryMetadataZod, "toSyncStepSummaryMetadata");
+var SyncStepSummaryStatusZod = z67.object({
+  currentBlock: z67.optional(XL1BlockNumberZod),
+  isIndexing: z67.boolean(),
+  nextBoundaries: z67.record(z67.string(), XL1BlockNumberZod),
+  summaries: z67.array(SyncStepSummaryMetadataZod),
+  summaryCount: z67.int().nonnegative()
 });
-var isSyncStepSummaryStatus = zodIsFactory19(SyncStepSummaryStatusZod);
-var asSyncStepSummaryStatus = zodAsFactory19(SyncStepSummaryStatusZod, "asSyncStepSummaryStatus");
-var toSyncStepSummaryStatus = zodToFactory18(SyncStepSummaryStatusZod, "toSyncStepSummaryStatus");
-var SyncStepSummaryZod = z62.array(SignedHydratedBlockWithHashMetaZod);
-var isSyncStepSummary = zodIsFactory19(SyncStepSummaryZod);
-var asSyncStepSummary = zodAsFactory19(SyncStepSummaryZod, "asSyncStepSummary");
-var toSyncStepSummary = zodToFactory18(SyncStepSummaryZod, "toSyncStepSummary");
+var isSyncStepSummaryStatus = zodIsFactory45(SyncStepSummaryStatusZod);
+var asSyncStepSummaryStatus = zodAsFactory47(SyncStepSummaryStatusZod, "asSyncStepSummaryStatus");
+var toSyncStepSummaryStatus = zodToFactory46(SyncStepSummaryStatusZod, "toSyncStepSummaryStatus");
+var SyncStepSummaryZod = z67.array(SignedHydratedBlockWithHashMetaZod);
+var isSyncStepSummary = zodIsFactory45(SyncStepSummaryZod);
+var asSyncStepSummary = zodAsFactory47(SyncStepSummaryZod, "asSyncStepSummary");
+var toSyncStepSummary = zodToFactory46(SyncStepSummaryZod, "toSyncStepSummary");
 
 // src/modules/protocol-model/model/TimeDomain.ts
-import { z as z63 } from "zod";
-var TimeDomainZod = z63.union([
-  z63.literal("xl1"),
-  z63.literal("epoch"),
-  z63.literal("ethereum")
+import { z as z68 } from "zod";
+var TimeDomainZod = z68.union([
+  z68.literal("xl1"),
+  z68.literal("epoch"),
+  z68.literal("ethereum")
 ]);
 
 // src/modules/protocol-model/model/TransactionInclusion.ts
 import {
-  HashZod as HashZod16,
-  zodAsFactory as zodAsFactory20,
-  zodIsFactory as zodIsFactory20,
-  zodToFactory as zodToFactory19
+  HashZod as HashZod18,
+  zodAsFactory as zodAsFactory48,
+  zodIsFactory as zodIsFactory46,
+  zodToFactory as zodToFactory47
 } from "@ariestools/sdk";
-import { z as z64 } from "zod";
-var TransactionInclusionZod = z64.object({
+import { z as z69 } from "zod";
+var TransactionInclusionZod = z69.object({
   /** Hash of the finalized block containing the transaction. */
-  blockHash: HashZod16,
+  blockHash: HashZod18,
   /** Number of the finalized block containing the transaction. */
   blockNumber: XL1BlockNumberZod,
   /** Hash of the included transaction. */
-  transactionHash: HashZod16,
+  transactionHash: HashZod18,
   /** Zero-based transaction position within the block. */
-  transactionIndex: z64.int().nonnegative()
+  transactionIndex: z69.int().nonnegative()
 });
-var isTransactionInclusion = zodIsFactory20(TransactionInclusionZod);
-var asTransactionInclusion = zodAsFactory20(TransactionInclusionZod, "asTransactionInclusion");
-var toTransactionInclusion = zodToFactory19(TransactionInclusionZod, "toTransactionInclusion");
+var isTransactionInclusion = zodIsFactory46(TransactionInclusionZod);
+var asTransactionInclusion = zodAsFactory48(TransactionInclusionZod, "asTransactionInclusion");
+var toTransactionInclusion = zodToFactory47(TransactionInclusionZod, "toTransactionInclusion");
 
 // src/modules/protocol-model/model/TransferPair.ts
-import { XyoAddressZod as XyoAddressZod18 } from "@xyo-network/sdk";
-import { z as z65 } from "zod";
-var TransferPairZod = z65.tuple([
-  XyoAddressZod18,
-  XyoAddressZod18
+import { XyoAddressZod as XyoAddressZod20 } from "@xyo-network/sdk";
+import { z as z70 } from "zod";
+var TransferPairZod = z70.tuple([
+  XyoAddressZod20,
+  XyoAddressZod20
 ]);
 
 // src/modules/protocol-model/model/version.ts
@@ -1926,57 +2148,59 @@ var asProviderMoniker = (value) => {
 var DefaultProviderMoniker = "Provider";
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory29 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema29,
-  isPayloadOfSchemaType as isPayloadOfSchemaType8,
-  PayloadZodOfSchema as PayloadZodOfSchema4
-} from "@xyo-network/sdk";
-import { z as z67 } from "zod/mini";
+  zodAsFactory as zodAsFactory49,
+  zodIsFactory as zodIsFactory47,
+  zodToFactory as zodToFactory48
+} from "@ariestools/sdk";
+import { asSchema as asSchema29, PayloadZodOfSchema as PayloadZodOfSchema29 } from "@xyo-network/sdk";
+import { z as z72 } from "zod/mini";
 
 // src/modules/protocol-model/rejection/RejectionError.ts
-import { HashZod as HashZod17 } from "@ariestools/sdk";
-import { z as z66 } from "zod";
-var RejectionErrorZod = z66.object({
-  hash: HashZod17,
-  message: z66.string().optional(),
-  name: z66.string()
+import { HashZod as HashZod19 } from "@ariestools/sdk";
+import { z as z71 } from "zod";
+var RejectionErrorZod = z71.object({
+  hash: HashZod19,
+  message: z71.string().optional(),
+  name: z71.string()
 }).loose();
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
 var BlockRejectionSchema = asSchema29("network.xyo.block.rejection", true);
-var BlockRejectionFieldsZod = z67.object({
+var BlockRejectionFieldsZod = z72.object({
   block: HydratedBlockZod,
-  errors: z67.array(RejectionErrorZod),
-  rejector: z67.string()
+  errors: z72.array(RejectionErrorZod),
+  rejector: z72.string()
 });
-var BlockRejectionZod = z67.extend(
-  PayloadZodOfSchema4(BlockRejectionSchema),
+var BlockRejectionZod = z72.extend(
+  PayloadZodOfSchema29(BlockRejectionSchema),
   BlockRejectionFieldsZod.shape
 );
-var isBlockRejection = isPayloadOfSchemaType8(BlockRejectionSchema);
-var asBlockRejection = AsObjectFactory29.create(isBlockRejection);
+var isBlockRejection = zodIsFactory47(BlockRejectionZod);
+var asBlockRejection = zodAsFactory49(BlockRejectionZod, "asBlockRejection");
+var toBlockRejection = zodToFactory48(BlockRejectionZod, "toBlockRejection");
 
 // src/modules/protocol-model/rejection/TransactionRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory30 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema30,
-  isPayloadOfSchemaType as isPayloadOfSchemaType9,
-  PayloadZodOfSchema as PayloadZodOfSchema5
-} from "@xyo-network/sdk";
-import { z as z68 } from "zod/mini";
+  zodAsFactory as zodAsFactory50,
+  zodIsFactory as zodIsFactory48,
+  zodToFactory as zodToFactory49
+} from "@ariestools/sdk";
+import { asSchema as asSchema30, PayloadZodOfSchema as PayloadZodOfSchema30 } from "@xyo-network/sdk";
+import { z as z73 } from "zod/mini";
 var TransactionRejectionSchema = asSchema30("network.xyo.transaction.rejection", true);
-var TransactionRejectionFieldsZod = z68.object({
-  errors: z68.array(RejectionErrorZod),
-  rejector: z68.string(),
+var TransactionRejectionFieldsZod = z73.object({
+  errors: z73.array(RejectionErrorZod),
+  rejector: z73.string(),
   transaction: HydratedTransactionZod
 });
-var TransactionRejectionZod = z68.extend(
-  PayloadZodOfSchema5(TransactionRejectionSchema),
+var TransactionRejectionZod = z73.extend(
+  PayloadZodOfSchema30(TransactionRejectionSchema),
   TransactionRejectionFieldsZod.shape
 );
-var isTransactionRejection = isPayloadOfSchemaType9(TransactionRejectionSchema);
-var asTransactionRejection = AsObjectFactory30.create(isTransactionRejection);
+var isTransactionRejection = zodIsFactory48(TransactionRejectionZod);
+var asTransactionRejection = zodAsFactory50(TransactionRejectionZod, "asTransactionRejection");
+var toTransactionRejection = zodToFactory49(TransactionRejectionZod, "toTransactionRejection");
 export {
   AccountBalanceConfigZod,
   AccountBalanceHistoryItemZod,
@@ -2001,6 +2225,8 @@ export {
   BlockContextZod,
   BlockDurationZod,
   BlockEndZod,
+  BlockNumberFieldsZod,
+  BlockNumberPayloadZod,
   BlockNumberSchema,
   BlockNumberZod,
   BlockNumberishZod,
@@ -2014,19 +2240,24 @@ export {
   BlockStartZod,
   BridgeDestinationObservationFieldsZod,
   BridgeDestinationObservationSchema,
+  BridgeDestinationObservationZod,
   BridgeDetailsDestinationFieldsZod,
   BridgeDetailsFieldsZod,
   BridgeDetailsSourceFieldsZod,
   BridgeIntentFieldsZod,
   BridgeIntentSchema,
+  BridgeIntentZod,
   BridgeSourceObservationFieldsZod,
   BridgeSourceObservationSchema,
+  BridgeSourceObservationZod,
   CachesZod,
   CachingContextZod,
   CandidatePairFieldsZod,
   CandidatePairSchema,
+  CandidatePairZod,
   CandidateSeenFieldsZod,
   CandidateSeenSchema,
+  CandidateSeenZod,
   CaveatTypesZod,
   CaveatsZod,
   ChainContextReadZod,
@@ -2038,7 +2269,9 @@ export {
   ChainQualifiedHeadConfigZod,
   ChainQualifiedRangeConfigZod,
   ChainQualifiedZod,
+  ChainStakeIntentFieldsZod,
   ChainStakeIntentSchema,
+  ChainStakeIntentZod,
   ChainZod,
   ClaimFieldsZod,
   ClaimSchema,
@@ -2058,13 +2291,18 @@ export {
   EvidenceDispositions,
   EvidenceNoteFieldsZod,
   EvidenceNoteSchema,
+  EvidenceNoteZod,
   ExchangeOutcomeFieldsZod,
   ExchangeOutcomeSchema,
+  ExchangeOutcomeZod,
   ExchangeTermsFieldsZod,
   ExchangeTermsSchema,
+  ExchangeTermsZod,
   ExtendChainQualifiedConfigZod,
   FemtoXL1,
   FemtoXL1MaxValue,
+  HashFieldsZod,
+  HashPayloadZod,
   HashSchema,
   HeadContextBaseZod,
   HeadContextZod,
@@ -2076,6 +2314,7 @@ export {
   HydratedTransactionZod,
   InscriptionFieldsZod,
   InscriptionSchema,
+  InscriptionZod,
   InvokerPermissionZod,
   JsonToArrayBufferZod,
   JsonToAttoZod,
@@ -2097,8 +2336,10 @@ export {
   OffenseCodes,
   OrdinalTransferFieldsZod,
   OrdinalTransferSchema,
+  OrdinalTransferZod,
   PartySecretRevealFieldsZod,
   PartySecretRevealSchema,
+  PartySecretRevealZod,
   PermissionRequestZod,
   PermissionZod,
   PicoXL1,
@@ -2133,19 +2374,27 @@ export {
   SingletonsZod,
   SlashAdjudicationFieldsZod,
   SlashAdjudicationSchema,
+  SlashAdjudicationZod,
   SlashChallengeFieldsZod,
   SlashChallengeSchema,
+  SlashChallengeZod,
   SlashCommitFieldsZod,
   SlashCommitSchema,
+  SlashCommitZod,
   SlashEvidenceFieldsZod,
   SlashEvidenceSchema,
+  SlashEvidenceZod,
   SlashOutcomeZod,
   SlashOutcomes,
   SlashRequestFieldsZod,
   SlashRequestSchema,
+  SlashRequestZod,
   StakeToJsonZod,
   StakeZod,
+  StepCompleteFieldsZod,
   StepCompleteSchema,
+  StepCompleteZod,
+  StepIdentityPayloadZod,
   StepIdentitySchema,
   StepIdentityZod,
   StepIndexZod,
@@ -2153,6 +2402,7 @@ export {
   StepSizes,
   StepWitnessFieldsZod,
   StepWitnessSchema,
+  StepWitnessZod,
   SyncStepSummaryMetadataZod,
   SyncStepSummaryStatusZod,
   SyncStepSummaryZod,
@@ -2167,10 +2417,13 @@ export {
   TokenAmountZod,
   TokenDeployFieldsZod,
   TokenDeploySchema,
+  TokenDeployZod,
   TokenMintFieldsZod,
   TokenMintSchema,
+  TokenMintZod,
   TokenTransferFieldsZod,
   TokenTransferSchema,
+  TokenTransferZod,
   TracerProviderZod,
   TransactionBoundWitnessFieldsZod,
   TransactionBoundWitnessIdentityFields,
@@ -2366,6 +2619,7 @@ export {
   isExecutable,
   isFemtoXL1,
   isHashPayload,
+  isHashPayloadWithStorageMeta,
   isHydratedBlock,
   isHydratedBlockWithHashMeta,
   isHydratedBlockWithStorageMeta,
@@ -2411,6 +2665,7 @@ export {
   isTimeConfig,
   isTimeDurations,
   isTimePayload,
+  isTimePayloadWithStorageMeta,
   isTokenDeploy,
   isTokenMint,
   isTokenTransfer,
@@ -2443,22 +2698,38 @@ export {
   toBlockBoundWitnessWithStorageMeta,
   toBlockNumber,
   toBlockNumberKey,
+  toBlockNumberPayload,
   toBlockRange,
   toBlockRate,
+  toBlockRejection,
+  toBridgeDestinationObservation,
+  toBridgeIntent,
+  toBridgeSourceObservation,
+  toCandidatePair,
+  toCandidateSeen,
   toChainId,
+  toChainStakeIntent,
+  toClaimPayload,
   toEthBlockNumber,
   toEthBlockNumberKey,
   toEthBlockRange,
+  toEvidenceNote,
+  toExchangeOutcome,
+  toExchangeTerms,
   toFemtoXL1,
+  toHashPayload,
   toHydratedBlock,
   toHydratedBlockWithHashMeta,
   toHydratedBlockWithStorageMeta,
   toHydratedTransaction,
   toHydratedTransactionWithHashMeta,
   toHydratedTransactionWithStorageMeta,
+  toInscription,
   toMicroXL1,
   toMilliXL1,
   toNanoXL1,
+  toOrdinalTransfer,
+  toPartySecretReveal,
   toPicoXL1,
   toRange,
   toSignedBlockBoundWitness,
@@ -2475,17 +2746,31 @@ export {
   toSignedTransactionBoundWitnessWithHashMeta,
   toSignedTransactionBoundWitnessWithStorageMeta,
   toSingleTimeConfig,
+  toSlashAdjudication,
+  toSlashChallenge,
+  toSlashCommit,
+  toSlashEvidence,
+  toSlashRequest,
+  toStepComplete,
+  toStepIdentityPayload,
+  toStepWitness,
   toSyncStepSummary,
   toSyncStepSummaryMetadata,
   toSyncStepSummaryStatus,
   toTimeConfig,
   toTimeDurations,
+  toTimePayload,
+  toTokenDeploy,
+  toTokenMint,
+  toTokenTransfer,
   toTransactionBoundWitness,
   toTransactionBoundWitnessWithHashMeta,
   toTransactionBoundWitnessWithStorageMeta,
   toTransactionFeesBigInt,
   toTransactionFeesHex,
   toTransactionInclusion,
+  toTransactionRejection,
+  toTransferPayload,
   toUnsignedBlockBoundWitness,
   toUnsignedHydratedTransaction,
   toUnsignedHydratedTransactionWithHashMeta,