@xyo-network/xl1-protocol-model 1.30.3 → 2.0.0

package/dist/neutral/index.mjs

@@ -6,62 +6,64 @@ import {
   isSchemaPayload,
   SchemaSchema
 } from "@xyo-network/sdk-js";
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 
 // src/payload/elevatable/Bridge/BridgeDestinationObservation.ts
 import { AsObjectFactory, HexZod as HexZod2 } from "@xylabs/sdk-js";
 import { asSchema, isPayloadOfZodType } from "@xyo-network/sdk-js";
+import { z as z2 } from "zod/mini";
 
 // src/payload/elevatable/Bridge/BridgeDetails.ts
 import { HexZod } from "@xylabs/sdk-js";
-import { z } from "zod";
+import { z } from "zod/mini";
 var BridgeDetailsDestinationFieldsZod = z.object({
   /**
    * Destination network
    */
-  dest: HexZod.describe("The destination network identifier"),
+  dest: HexZod.check(z.describe("The destination network identifier")),
   /**
    * Destination address (EOA or contract)
    */
-  destAddress: HexZod.describe("The destination address (EOA or contract)"),
+  destAddress: HexZod.check(z.describe("The destination address (EOA or contract)")),
   /**
    * Token amount to bridge to destination
    */
-  destAmount: HexZod.describe("The token amount to bridge to destination"),
+  destAmount: HexZod.check(z.describe("The token amount to bridge to destination")),
   /**
    * Token being bridged to
    */
-  destToken: HexZod.describe("The token being bridged to")
+  destToken: HexZod.check(z.describe("The token being bridged to"))
 });
 var BridgeDetailsSourceFieldsZod = z.object({
   /**
    * Source network
    */
-  src: HexZod.describe("The source network identifier"),
+  src: HexZod.check(z.describe("The source network identifier")),
   /**
    * Source address (EOA or contract)
    */
-  srcAddress: HexZod.describe("The source address (EOA or contract)"),
+  srcAddress: HexZod.check(z.describe("The source address (EOA or contract)")),
   /**
    * Token amount to bridge from source
    */
-  srcAmount: HexZod.describe("The token amount to bridge from source"),
+  srcAmount: HexZod.check(z.describe("The token amount to bridge from source")),
   /**
    * Token being bridged from
    */
-  srcToken: HexZod.describe("The token being bridged from")
+  srcToken: HexZod.check(z.describe("The token being bridged from"))
 });
-var BridgeDetailsFieldsZod = BridgeDetailsSourceFieldsZod.extend(
+var BridgeDetailsFieldsZod = z.extend(
+  BridgeDetailsSourceFieldsZod,
   BridgeDetailsDestinationFieldsZod.shape
 );
 
 // src/payload/elevatable/Bridge/BridgeDestinationObservation.ts
 var BridgeDestinationObservationSchema = asSchema("network.xyo.chain.bridge.observation.destination", true);
-var BridgeDestinationObservationFieldsZod = BridgeDetailsFieldsZod.extend({
+var BridgeDestinationObservationFieldsZod = z2.extend(BridgeDetailsFieldsZod, {
   /**
    * Destination chain confirmation
    */
-  destConfirmation: HexZod2.optional().describe("Destination chain confirmation")
+  destConfirmation: z2.optional(HexZod2).check(z2.describe("Destination chain confirmation"))
 });
 var isBridgeDestinationObservation = isPayloadOfZodType(
   BridgeDestinationObservationFieldsZod,
@@ -72,13 +74,13 @@ var asBridgeDestinationObservation = AsObjectFactory.create(isBridgeDestinationO
 // src/payload/elevatable/Bridge/BridgeIntent.ts
 import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk-js";
 import { asSchema as asSchema2, isPayloadOfZodType as isPayloadOfZodType2 } from "@xyo-network/sdk-js";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod/mini";
 var BridgeIntentSchema = asSchema2("network.xyo.chain.bridge.intent", true);
-var BridgeIntentFieldsZod = BridgeDetailsFieldsZod.extend({
+var BridgeIntentFieldsZod = z3.extend(BridgeDetailsFieldsZod, {
   /**
    * Unique identifier for replay protection
    */
-  nonce: z2.string().describe("Unique identifier for replay protection")
+  nonce: z3.string().check(z3.describe("Unique identifier for replay protection"))
 });
 var isBridgeIntent = isPayloadOfZodType2(
   BridgeIntentFieldsZod,
@@ -89,12 +91,13 @@ var asBridgeIntent = AsObjectFactory2.create(isBridgeIntent);
 // src/payload/elevatable/Bridge/BridgeSourceObservation.ts
 import { AsObjectFactory as AsObjectFactory3, HexZod as HexZod3 } from "@xylabs/sdk-js";
 import { asSchema as asSchema3, isPayloadOfZodType as isPayloadOfZodType3 } from "@xyo-network/sdk-js";
+import { z as z4 } from "zod/mini";
 var BridgeSourceObservationSchema = asSchema3("network.xyo.chain.bridge.observation.source", true);
-var BridgeSourceObservationFieldsZod = BridgeDetailsFieldsZod.extend({
+var BridgeSourceObservationFieldsZod = z4.extend(BridgeDetailsFieldsZod, {
   /**
    * Source chain confirmation
    */
-  srcConfirmation: HexZod3.optional().describe("Source chain confirmation")
+  srcConfirmation: z4.optional(HexZod3).check(z4.describe("Source chain confirmation"))
 });
 var isBridgeSourceObservation = isPayloadOfZodType3(
   BridgeSourceObservationFieldsZod,
@@ -155,26 +158,29 @@ import {
   isPayloadOfSchemaType as isPayloadOfSchemaType4,
   PayloadZodOfSchema
 } from "@xyo-network/sdk-js";
-import { z as z3 } from "zod";
+import { z as z5 } from "zod/mini";
 var TimeSchema = asSchema7("network.xyo.time", true);
-var XL1TimeFieldsZod = z3.object({
+var XL1TimeFieldsZod = z5.object({
   // block number
-  xl1: z3.number().optional(),
+  xl1: z5.optional(z5.number()),
   // block hash
-  xl1Hash: HashZod.optional()
+  xl1Hash: z5.optional(HashZod)
 });
-var EthereumTimeFieldsZod = z3.object({
+var EthereumTimeFieldsZod = z5.object({
   // block number
-  ethereum: z3.number().optional(),
+  ethereum: z5.optional(z5.number()),
   // block hash
-  ethereumHash: HashZod.optional()
+  ethereumHash: z5.optional(HashZod)
 });
-var EpochTimeFieldsZod = z3.object({
+var EpochTimeFieldsZod = z5.object({
   // in milliseconds
-  epoch: z3.number()
+  epoch: z5.number()
 });
-var TimeFieldsZod = XL1TimeFieldsZod.extend(XL1TimeFieldsZod.shape).extend(EthereumTimeFieldsZod.shape).extend(EpochTimeFieldsZod.shape);
-var TimePayloadZod = PayloadZodOfSchema(TimeSchema).extend(TimeFieldsZod.shape);
+var TimeFieldsZod = z5.extend(
+  z5.extend(z5.extend(XL1TimeFieldsZod, XL1TimeFieldsZod.shape), EthereumTimeFieldsZod.shape),
+  EpochTimeFieldsZod.shape
+);
+var TimePayloadZod = z5.extend(PayloadZodOfSchema(TimeSchema), TimeFieldsZod.shape);
 var isSafeEpoch = (value) => {
   return typeof value === "number" && value < 2 * Date.now();
 };
@@ -190,18 +196,18 @@ import { asSchema as asSchema8, isPayloadOfZodType as isPayloadOfZodType4 } from
 
 // src/Step/StepIdentity.ts
 import { isUndefined } from "@xylabs/sdk-js";
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 
 // src/BlockNumber/BlockNumber.ts
 import { zodAsFactory, zodToFactory } from "@xylabs/sdk-js";
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 
 // src/BlockNumber/Numberish.ts
-import { z as z4 } from "zod";
-var NumberishZod = z4.union([z4.number(), z4.string(), z4.bigint()]).transform((v) => typeof v === "bigint" ? Number(v) : typeof v === "string" ? Number(v) : v).pipe(z4.number());
+import { z as z6 } from "zod";
+var NumberishZod = z6.union([z6.number(), z6.string(), z6.bigint()]).transform((v) => typeof v === "bigint" ? Number(v) : typeof v === "string" ? Number(v) : v).pipe(z6.number());
 
 // src/BlockNumber/BlockNumber.ts
-var BlockNumberZod = z5.number().transform((v) => v);
+var BlockNumberZod = z7.number().transform((v) => v);
 var BlockNumberishZod = NumberishZod.transform((v) => v);
 var asBlockNumber = zodAsFactory(BlockNumberZod, "asBlockNumber");
 var toBlockNumber = zodToFactory(BlockNumberishZod, "toBlockNumber");
@@ -209,8 +215,8 @@ var BLOCK_NUMBER_ZERO = asBlockNumber(0);
 
 // src/BlockNumber/EthBlockNumber.ts
 import { zodAsFactory as zodAsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/sdk-js";
-import { z as z6 } from "zod";
-var EthBlockNumberZod = z6.number().transform((v) => v);
+import { z as z8 } from "zod";
+var EthBlockNumberZod = z8.number().transform((v) => v);
 var EthBlockNumberishZod = BlockNumberishZod.transform((v) => v);
 var asEthBlockNumber = zodAsFactory2(EthBlockNumberZod, "asEthBlockNumber");
 var toEthBlockNumber = zodToFactory2(EthBlockNumberishZod, "toEthBlockNumber");
@@ -218,17 +224,17 @@ var ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0);
 
 // src/BlockNumber/XL1BlockNumber.ts
 import { zodAsFactory as zodAsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/sdk-js";
-import { z as z7 } from "zod";
-var XL1BlockNumberZod = z7.number().transform((v) => v);
+import { z as z9 } from "zod";
+var XL1BlockNumberZod = z9.number().transform((v) => v);
 var XL1BlockNumberishZod = BlockNumberishZod.transform((v) => v);
 var asXL1BlockNumber = zodAsFactory3(XL1BlockNumberZod, "asXL1BlockNumber");
 var toXL1BlockNumber = zodToFactory3(XL1BlockNumberishZod, "toXL1BlockNumber");
 var XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0);
 
 // src/Step/StepIdentity.ts
-var StepIdentityZod = z8.object({
+var StepIdentityZod = z10.object({
   block: XL1BlockNumberZod.describe("The block number at which the step occurs"),
-  step: z8.number().int().nonnegative().describe("The index of the step into the StepSize array")
+  step: z10.number().int().nonnegative().describe("The index of the step into the StepSize array")
 });
 function tryParseInt(value) {
   if (value === "") return void 0;
@@ -314,12 +320,12 @@ import {
   WithHashMetaZod,
   WithStorageMetaZod
 } from "@xyo-network/sdk-js";
-import { z as z12 } from "zod";
+import { z as z14 } from "zod/mini";
 
 // src/chain/Chain.ts
 import { AddressRegEx, toAddress } from "@xylabs/sdk-js";
-import { z as z9 } from "zod";
-var ChainZod = z9.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
+import { z as z11 } from "zod";
+var ChainZod = z11.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
 // src/transaction/TransactionFees.ts
 import {
@@ -330,10 +336,10 @@ import {
   zodIsFactory,
   zodToFactory as zodToFactory4
 } from "@xylabs/sdk-js";
-import { z as z11 } from "zod";
+import { z as z13 } from "zod/mini";
 
 // src/xl1/isXL1Factory.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 
 // src/xl1/xl1MaxValue.ts
 var xl1MaxValue = (places) => 10n ** (32n - places) - 1n;
@@ -346,7 +352,7 @@ var isXL1Factory = (places) => (val) => {
 var XL1ZodFactory = (places, name) => {
   const is = isXL1Factory(places);
   const message = `Invalid value for ${name}, must be between 0 and ${xl1MaxValue(places)}`;
-  return z10.bigint().refine(
+  return z12.bigint().refine(
     (x) => {
       const result = is(x);
       return result;
@@ -357,7 +363,7 @@ var XL1ZodFactory = (places, name) => {
 var XL1TransformZodFactory = (places, name) => {
   const is = isXL1Factory(places);
   const message = `Invalid value for ${name}, must be between 0 and ${xl1MaxValue(places)}`;
-  return z10.union([z10.bigint(), z10.number(), z10.string(), z10.boolean()]).transform((val) => BigInt(val)).refine(
+  return z12.union([z12.bigint(), z12.number(), z12.string(), z12.boolean()]).transform((val) => BigInt(val)).refine(
     (x) => {
       const result = is(x);
       return result;
@@ -454,9 +460,9 @@ var XL1 = asXL1;
 
 // src/transaction/TransactionFees.ts
 import { BigIntToJsonZod as BigIntToJsonZod2 } from "@xylabs/sdk-js";
-var AttoZod = z11.bigint();
-var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
-var TransactionFeesHexZod = z11.object({
+var AttoZod = z13.bigint();
+var JsonToAttoZod = z13.pipe(JsonToBigIntZod, z13.transform((v) => asAttoXL1(v)));
+var TransactionFeesHexZod = z13.object({
   base: HexZod4,
   gasLimit: HexZod4,
   gasPrice: HexZod4,
@@ -465,7 +471,7 @@ var TransactionFeesHexZod = z11.object({
 var isTransactionFeesHex = zodIsFactory(TransactionFeesHexZod);
 var asTransactionFeesHex = zodAsFactory4(TransactionFeesHexZod, "asTransactionFeesHex");
 var toTransactionFeesHex = zodToFactory4(TransactionFeesHexZod, "toTransactionFeesHex");
-var TransactionFeesBigIntZod = z11.object({
+var TransactionFeesBigIntZod = z13.object({
   base: AttoZod,
   gasLimit: AttoZod,
   gasPrice: AttoZod,
@@ -474,44 +480,59 @@ var TransactionFeesBigIntZod = z11.object({
 var isTransactionFeesBigInt = zodIsFactory(TransactionFeesBigIntZod);
 var asTransactionFeesBigInt = zodAsFactory4(TransactionFeesBigIntZod, "asTransactionFeesBigInt");
 var toTransactionFeesBigInt = zodToFactory4(TransactionFeesBigIntZod, "toTransactionFeesBigInt");
-var TransactionFeesJsonToBigIntZod = TransactionFeesHexZod.transform((val) => ({
-  base: JsonToBigIntZod.parse(val.base),
-  gasLimit: JsonToBigIntZod.parse(val.gasLimit),
-  gasPrice: JsonToBigIntZod.parse(val.gasPrice),
-  priority: JsonToBigIntZod.parse(val.priority)
-}));
-var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) => ({
-  base: BigIntToJsonZod.parse(val.base),
-  gasLimit: BigIntToJsonZod.parse(val.gasLimit),
-  gasPrice: BigIntToJsonZod.parse(val.gasPrice),
-  priority: BigIntToJsonZod.parse(val.priority)
-}));
+var TransactionFeesJsonToBigIntZod = z13.pipe(
+  TransactionFeesHexZod,
+  z13.transform((val) => ({
+    base: JsonToBigIntZod.parse(val.base),
+    gasLimit: JsonToBigIntZod.parse(val.gasLimit),
+    gasPrice: JsonToBigIntZod.parse(val.gasPrice),
+    priority: JsonToBigIntZod.parse(val.priority)
+  }))
+);
+var TransactionFeesBigIntToJsonZod = z13.pipe(
+  TransactionFeesBigIntZod,
+  z13.transform((val) => ({
+    base: BigIntToJsonZod.parse(val.base),
+    gasLimit: BigIntToJsonZod.parse(val.gasLimit),
+    gasPrice: BigIntToJsonZod.parse(val.gasPrice),
+    priority: BigIntToJsonZod.parse(val.priority)
+  }))
+);
 
 // src/transaction/TransactionBoundWitness.ts
-var BlockStartZod = z12.object({ nbf: XL1BlockNumberZod });
-var BlockEndZod = z12.object({ exp: XL1BlockNumberZod });
-var BlockDurationZod = z12.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod });
-var BlockScriptsZod = z12.object({ script: z12.array(z12.string()).optional() });
-var TransactionFeesZod = z12.object({ fees: TransactionFeesHexZod });
-var TransactionBoundWitnessIdentityFields = z12.object({ chain: ChainZod, from: AddressZod });
-var TransactionBoundWitnessFieldsZod = z12.object().safeExtend(BlockDurationZod.shape).safeExtend(TransactionFeesZod.shape).safeExtend(TransactionBoundWitnessIdentityFields.shape).safeExtend(BlockScriptsZod.shape);
-var TransactionBoundWitnessZod = BoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
+var BlockStartZod = z14.object({ nbf: XL1BlockNumberZod });
+var BlockEndZod = z14.object({ exp: XL1BlockNumberZod });
+var BlockDurationZod = z14.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod });
+var BlockScriptsZod = z14.object({ script: z14.optional(z14.array(z14.string())) });
+var TransactionFeesZod = z14.object({ fees: TransactionFeesHexZod });
+var TransactionBoundWitnessIdentityFields = z14.object({ chain: ChainZod, from: AddressZod });
+var TransactionBoundWitnessFieldsZod = z14.safeExtend(
+  z14.safeExtend(
+    z14.safeExtend(
+      z14.safeExtend(z14.object(), BlockDurationZod.shape),
+      TransactionFeesZod.shape
+    ),
+    TransactionBoundWitnessIdentityFields.shape
+  ),
+  BlockScriptsZod.shape
+);
+var TransactionBoundWitnessZod = z14.safeExtend(BoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
 var isTransactionBoundWitness = zodIsFactory2(TransactionBoundWitnessZod);
 var asTransactionBoundWitness = zodAsFactory5(TransactionBoundWitnessZod, "asTransactionBoundWitness");
 var toTransactionBoundWitness = zodToFactory5(TransactionBoundWitnessZod, "toTransactionBoundWitness");
-var TransactionBoundWitnessWithHashMetaZod = TransactionBoundWitnessZod.safeExtend(HashMetaZod.shape);
+var TransactionBoundWitnessWithHashMetaZod = z14.safeExtend(TransactionBoundWitnessZod, HashMetaZod.shape);
 var isTransactionBoundWitnessWithHashMeta = zodIsFactory2(TransactionBoundWitnessWithHashMetaZod);
 var asTransactionBoundWitnessWithHashMeta = zodAsFactory5(TransactionBoundWitnessWithHashMetaZod, "asTransactionBoundWitnessWithHashMeta");
 var toTransactionBoundWitnessWithHashMeta = zodToFactory5(TransactionBoundWitnessWithHashMetaZod, "toTransactionBoundWitnessWithHashMeta");
-var TransactionBoundWitnessWithStorageMetaZod = TransactionBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var TransactionBoundWitnessWithStorageMetaZod = z14.safeExtend(TransactionBoundWitnessZod, StorageMetaZod.shape);
 var isTransactionBoundWitnessWithStorageMeta = zodIsFactory2(TransactionBoundWitnessWithStorageMetaZod);
 var asTransactionBoundWitnessWithStorageMeta = zodAsFactory5(TransactionBoundWitnessWithStorageMetaZod, "asTransactionBoundWitnessWithStorageMeta");
 var toTransactionBoundWitnessWithStorageMeta = zodToFactory5(TransactionBoundWitnessWithStorageMetaZod, "toTransactionBoundWitnessWithStorageMeta");
-var UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
+var UnsignedTransactionBoundWitnessZod = z14.safeExtend(UnsignedBoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
 var isUnsignedTransactionBoundWitness = zodIsFactory2(UnsignedTransactionBoundWitnessZod);
 var asUnsignedTransactionBoundWitness = zodAsFactory5(UnsignedTransactionBoundWitnessZod, "asUnsignedTransactionBoundWitness");
 var toUnsignedTransactionBoundWitness = zodToFactory5(UnsignedTransactionBoundWitnessZod, "toUnsignedTransactionBoundWitness");
-var UnsignedTransactionBoundWitnessWithHashMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(HashMetaZod.shape);
+var UnsignedTransactionBoundWitnessWithHashMetaZod = z14.safeExtend(UnsignedTransactionBoundWitnessZod, HashMetaZod.shape);
 var isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory2(UnsignedTransactionBoundWitnessWithHashMetaZod);
 var asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory5(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
@@ -521,7 +542,7 @@ var toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory5(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   "toUnsignedTransactionBoundWitnessWithHashMeta"
 );
-var UnsignedTransactionBoundWitnessWithStorageMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var UnsignedTransactionBoundWitnessWithStorageMetaZod = z14.safeExtend(UnsignedTransactionBoundWitnessZod, StorageMetaZod.shape);
 var isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory2(UnsignedTransactionBoundWitnessWithStorageMetaZod);
 var asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory5(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
@@ -531,7 +552,7 @@ var toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory5(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   "toUnsignedTransactionBoundWitnessWithStorageMeta"
 );
-var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
+var SignedTransactionBoundWitnessZod = z14.safeExtend(SignedBoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
 var isSignedTransactionBoundWitness = zodIsFactory2(SignedTransactionBoundWitnessZod);
 var asSignedTransactionBoundWitness = zodAsFactory5(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
 var toSignedTransactionBoundWitness = zodToFactory5(SignedTransactionBoundWitnessZod, "toSignedTransactionBoundWitness");
@@ -585,17 +606,17 @@ import {
   isPayloadOfSchemaType as isPayloadOfSchemaType5,
   PayloadZodOfSchema as PayloadZodOfSchema2
 } from "@xyo-network/sdk-js";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod/mini";
 var TransferSchema = asSchema9("network.xyo.transfer", true);
-var TransferFieldsZod = z13.object({
+var TransferFieldsZod = z15.object({
   // Removed as only transaction have opCodes
   // $opCodes: z.array(z.string()).optional(),
-  context: JsonObjectZod.optional(),
-  epoch: z13.number(),
+  context: z15.optional(JsonObjectZod),
+  epoch: z15.number(),
   from: AddressZod2,
-  transfers: z13.record(AddressZod2, HexZod5)
+  transfers: z15.record(AddressZod2, HexZod5)
 });
-var TransferZod = PayloadZodOfSchema2(TransferSchema).extend(TransferFieldsZod.shape);
+var TransferZod = z15.extend(PayloadZodOfSchema2(TransferSchema), TransferFieldsZod.shape);
 var isTransfer = isPayloadOfSchemaType5(TransferSchema);
 var asTransfer = AsObjectFactory9.create(isTransfer);
 
@@ -612,7 +633,7 @@ var AllowedBlockPayloadSchemas = [
   TimeSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadSchemaZod = z14.enum(AllowedBlockPayloadSchemas);
+var AllowedBlockPayloadSchemaZod = z16.enum(AllowedBlockPayloadSchemas);
 var isAllowedBlockPayloadSchema = zodIsFactory3(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (value) => {
   return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isTimePayload(value) || isTransactionBoundWitness(value);
@@ -633,16 +654,16 @@ import {
   WithHashMetaZod as WithHashMetaZod2,
   WithStorageMetaZod as WithStorageMetaZod2
 } from "@xyo-network/sdk-js";
-import { z as z15 } from "zod";
-var BlockBoundWitnessFieldsZod = z15.object({
+import { z as z17 } from "zod/mini";
+var BlockBoundWitnessFieldsZod = z17.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: HashZod2.nullable(),
-  protocol: z15.number().optional(),
-  step_hashes: z15.array(HashZod2).optional()
+  previous: z17.nullable(HashZod2),
+  protocol: z17.optional(z17.number()),
+  step_hashes: z17.optional(z17.array(HashZod2))
 });
-var BlockBoundWitnessMetaZod = z15.object({ $epoch: z15.number() });
-var BlockBoundWitnessZod = z15.object({
+var BlockBoundWitnessMetaZod = z17.object({ $epoch: z17.number() });
+var BlockBoundWitnessZod = z17.object({
   ...BoundWitnessZod2.shape,
   ...BlockBoundWitnessFieldsZod.shape,
   ...BlockBoundWitnessMetaZod.shape
@@ -671,7 +692,7 @@ import {
   WithHashMetaZod as WithHashMetaZod4,
   WithStorageMetaZod as WithStorageMetaZod4
 } from "@xyo-network/sdk-js";
-import { z as z16 } from "zod";
+import { z as z21 } from "zod/mini";
 
 // src/block/signed/SignedBlockBoundWitness.ts
 import {
@@ -680,7 +701,11 @@ import {
   zodToFactory as zodToFactory7
 } from "@xylabs/sdk-js";
 import { SignedBoundWitnessZod as SignedBoundWitnessZod2 } from "@xyo-network/sdk-js";
-var SignedBlockBoundWitnessZod = SignedBoundWitnessZod2.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
+import { z as z18 } from "zod/mini";
+var SignedBlockBoundWitnessZod = z18.safeExtend(
+  z18.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+  BlockBoundWitnessMetaZod.shape
+);
 var isSignedBlockBoundWitness = zodIsFactory5(SignedBlockBoundWitnessZod);
 var asSignedBlockBoundWitness = zodAsFactory7(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
 var toSignedBlockBoundWitness = zodToFactory7(SignedBlockBoundWitnessZod, "toSignedBlockBoundWitness");
@@ -692,18 +717,22 @@ import {
   zodToFactory as zodToFactory8
 } from "@xylabs/sdk-js";
 import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk-js";
+import { z as z19 } from "zod/mini";
 var SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod3(SignedBlockBoundWitnessZod);
 var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory6(SignedBlockBoundWitnessWithHashMetaZod);
 var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory8(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
-var SignedBlockBoundWitnessWithHashMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
-  if (isSignedBlockBoundWitnessWithHashMeta(data)) {
-    return data;
-  }
-  if (isSignedBlockBoundWitness(data)) {
-    return await PayloadBuilder.addHashMeta(data);
-  }
-  throw new Error("Invalid SignedBlockBoundWitnessWithHashMetaish format");
-});
+var SignedBlockBoundWitnessWithHashMetaishZod = z19.pipe(
+  SignedBlockBoundWitnessZod,
+  z19.transform(async (data) => {
+    if (isSignedBlockBoundWitnessWithHashMeta(data)) {
+      return data;
+    }
+    if (isSignedBlockBoundWitness(data)) {
+      return await PayloadBuilder.addHashMeta(data);
+    }
+    throw new Error("Invalid SignedBlockBoundWitnessWithHashMetaish format");
+  })
+);
 var toSignedBlockBoundWitnessWithHashMeta = zodToFactory8(SignedBlockBoundWitnessWithHashMetaZod, "toSignedBlockBoundWitnessWithHashMeta");
 
 // src/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts
@@ -713,83 +742,87 @@ import {
   zodToFactory as zodToFactory9
 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod3 } from "@xyo-network/sdk-js";
+import { z as z20 } from "zod/mini";
 var SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod3(SignedBlockBoundWitnessZod);
 var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory7(SignedBlockBoundWitnessWithStorageMetaZod);
 var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory9(
   SignedBlockBoundWitnessWithStorageMetaZod,
   "asSignedBlockBoundWitnessWithStorageMeta"
 );
-var SignedBlockBoundWitnessWithStorageMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
-  if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
-    return data;
-  }
-  if (isSignedBlockBoundWitness(data)) {
-    return await PayloadBuilder2.addStorageMeta(data);
-  }
-  throw new Error("Invalid SignedBlockBoundWitnessWithStorageMetaish format");
-});
+var SignedBlockBoundWitnessWithStorageMetaishZod = z20.pipe(
+  SignedBlockBoundWitnessZod,
+  z20.transform(async (data) => {
+    if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
+      return data;
+    }
+    if (isSignedBlockBoundWitness(data)) {
+      return await PayloadBuilder2.addStorageMeta(data);
+    }
+    throw new Error("Invalid SignedBlockBoundWitnessWithStorageMetaish format");
+  })
+);
 var toSignedBlockBoundWitnessWithStorageMeta = zodToFactory9(
   SignedBlockBoundWitnessWithStorageMetaishZod,
   "toSignedBlockBoundWitnessWithStorageMeta"
 );
 
 // src/block/HydratedBlock.ts
-var HydratedBlockZod = z16.tuple([
+var HydratedBlockZod = z21.tuple([
   BlockBoundWitnessZod,
-  z16.array(PayloadZodLoose)
+  z21.array(PayloadZodLoose)
 ]);
 var isHydratedBlock = zodIsFactory8(HydratedBlockZod);
 var asHydratedBlock = zodAsFactory10(HydratedBlockZod, "asHydratedBlock");
 var toHydratedBlock = zodToFactory10(HydratedBlockZod, "toHydratedBlock");
-var HydratedBlockWithHashMetaZod = z16.tuple([
+var HydratedBlockWithHashMetaZod = z21.tuple([
   WithHashMetaZod4(BlockBoundWitnessZod),
-  z16.array(WithHashMetaZod4(PayloadZod).loose())
+  z21.array(z21.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
 var isHydratedBlockWithHashMeta = zodIsFactory8(HydratedBlockWithHashMetaZod);
 var asHydratedBlockWithHashMeta = zodAsFactory10(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
 var toHydratedBlockWithHashMeta = zodToFactory10(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
-var HydratedBlockWithStorageMetaZod = z16.tuple([
+var HydratedBlockWithStorageMetaZod = z21.tuple([
   WithStorageMetaZod4(BlockBoundWitnessZod),
-  z16.array(WithStorageMetaZod4(PayloadZod).loose())
+  z21.array(z21.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 var isHydratedBlockWithStorageMeta = zodIsFactory8(HydratedBlockWithStorageMetaZod);
 var asHydratedBlockWithStorageMeta = zodAsFactory10(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
 var toHydratedBlockWithStorageMeta = zodToFactory10(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
-var SignedHydratedBlockZod = z16.tuple([
+var SignedHydratedBlockZod = z21.tuple([
   SignedBlockBoundWitnessZod,
-  z16.array(PayloadZod.loose())
+  z21.array(z21.looseObject(PayloadZod.shape))
 ]);
 var isSignedHydratedBlock = zodIsFactory8(SignedHydratedBlockZod);
 var asSignedHydratedBlock = zodAsFactory10(SignedHydratedBlockZod, "asSignedHydratedBlock");
 var toSignedHydratedBlock = zodToFactory10(SignedHydratedBlockZod, "toSignedHydratedBlock");
-var SignedHydratedBlockToJsonZod = z16.tuple([
+var SignedHydratedBlockToJsonZod = z21.tuple([
   SignedBlockBoundWitnessZod,
-  z16.array(PayloadZod.loose())
+  z21.array(z21.looseObject(PayloadZod.shape))
 ]);
 var isSignedHydratedBlockToJson = zodIsFactory8(SignedHydratedBlockToJsonZod);
 var asSignedHydratedBlockToJson = zodAsFactory10(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
 var toSignedHydratedBlockToJson = zodToFactory10(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
-var SignedHydratedBlockWithHashMetaZod = z16.tuple([
+var SignedHydratedBlockWithHashMetaZod = z21.tuple([
   WithHashMetaZod4(SignedBlockBoundWitnessZod),
-  z16.array(WithHashMetaZod4(PayloadZod).loose())
+  z21.array(z21.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var SignedHydratedBlockWithHashMetaishZod = z16.tuple([
-  z16.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
-  z16.array(WithHashMetaZod4(PayloadZod).loose())
+var SignedHydratedBlockWithHashMetaishZod = z21.tuple([
+  z21.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
+  z21.array(z21.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
 var isSignedHydratedBlockWithHashMeta = zodIsFactory8(SignedHydratedBlockWithHashMetaZod);
 var asSignedHydratedBlockWithHashMeta = zodAsFactory10(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
 var toSignedHydratedBlockWithHashMeta = zodToFactory10(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
-var SignedHydratedBlockWithStorageMetaZod = z16.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z21.tuple([
   WithStorageMetaZod4(SignedBlockBoundWitnessZod),
-  z16.array(WithStorageMetaZod4(PayloadZod).loose())
+  z21.array(z21.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 var isSignedHydratedBlockWithStorageMeta = zodIsFactory8(SignedHydratedBlockWithStorageMetaZod);
 var asSignedHydratedBlockWithStorageMeta = zodAsFactory10(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
 var toSignedHydratedBlockWithStorageMeta = zodToFactory10(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
-var SignedHydratedBlockWithStorageMetaishZod = z16.tuple([
-  z16.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
-  z16.array(WithStorageMetaZod4(PayloadZod).loose())
+var SignedHydratedBlockWithStorageMetaishZod = z21.tuple([
+  z21.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
+  z21.array(z21.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 
 // src/block/unsigned/UnsignedBlockBoundWitness.ts
@@ -799,7 +832,11 @@ import {
   zodToFactory as zodToFactory11
 } from "@xylabs/sdk-js";
 import { UnsignedBoundWitnessZod as UnsignedBoundWitnessZod2 } from "@xyo-network/sdk-js";
-var UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod2.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
+import { z as z22 } from "zod/mini";
+var UnsignedBlockBoundWitnessZod = z22.safeExtend(
+  z22.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+  BlockBoundWitnessMetaZod.shape
+);
 var isUnsignedBlockBoundWitness = zodIsFactory9(UnsignedBlockBoundWitnessZod);
 var asUnsignedBlockBoundWitness = zodAsFactory11(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
 var toUnsignedBlockBoundWitness = zodToFactory11(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
@@ -820,11 +857,11 @@ var asBlockNumberPayloadWithSources = AsObjectFactory10.create(isBlockNumberPayl
 // src/model/AccountBalance.ts
 import { zodIsFactory as zodIsFactory12 } from "@xylabs/sdk-js";
 import { WithHashMetaZod as WithHashMetaZod5 } from "@xyo-network/sdk-js";
-import { z as z22 } from "zod";
+import { z as z28 } from "zod/mini";
 
 // src/model/ChainQualification.ts
 import { HashZod as HashZod3, zodIsFactory as zodIsFactory11 } from "@xylabs/sdk-js";
-import { z as z21 } from "zod";
+import { z as z27 } from "zod";
 
 // src/model/BlockRange/BlockRange.ts
 import {
@@ -833,9 +870,9 @@ import {
   zodAsFactory as zodAsFactory12,
   zodToFactory as zodToFactory12
 } from "@xylabs/sdk-js";
-import { z as z17 } from "zod";
-var BlockRangeZod = z17.tuple([BlockNumberZod, BlockNumberZod]);
-var BlockRangeishZod = z17.tuple([BlockNumberishZod, BlockNumberishZod]);
+import { z as z23 } from "zod";
+var BlockRangeZod = z23.tuple([BlockNumberZod, BlockNumberZod]);
+var BlockRangeishZod = z23.tuple([BlockNumberishZod, BlockNumberishZod]);
 var asBlockRange = zodAsFactory12(BlockRangeZod, "BlockRange");
 var toBlockRange = zodToFactory12(BlockRangeishZod, "BlockRange");
 var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -852,9 +889,9 @@ import {
   zodAsFactory as zodAsFactory13,
   zodToFactory as zodToFactory13
 } from "@xylabs/sdk-js";
-import { z as z18 } from "zod";
-var EthBlockRangeZod = z18.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-var EthBlockRangeishZod = z18.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
+import { z as z24 } from "zod";
+var EthBlockRangeZod = z24.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var EthBlockRangeishZod = z24.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
 var asEthBlockRange = zodAsFactory13(EthBlockRangeZod, "EthBlockRange");
 var toEthBlockRange = zodToFactory13(EthBlockRangeishZod, "EthBlockRange");
 var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -870,8 +907,8 @@ import {
   zodIsFactory as zodIsFactory10,
   zodToFactory as zodToFactory14
 } from "@xylabs/sdk-js";
-import { z as z19 } from "zod";
-var RangeZod = z19.tuple([z19.number(), z19.number()]);
+import { z as z25 } from "zod";
+var RangeZod = z25.tuple([z25.number(), z25.number()]);
 var isRange = zodIsFactory10(RangeZod);
 var asRange = zodAsFactory14(RangeZod, "Range");
 var toRange = zodToFactory14(RangeZod, "Range");
@@ -883,9 +920,9 @@ import {
   zodAsFactory as zodAsFactory15,
   zodToFactory as zodToFactory15
 } from "@xylabs/sdk-js";
-import { z as z20 } from "zod";
-var XL1BlockRangeZod = z20.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-var XL1BlockRangeishZod = z20.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
+import { z as z26 } from "zod";
+var XL1BlockRangeZod = z26.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var XL1BlockRangeishZod = z26.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
 var asXL1BlockRange = zodAsFactory15(XL1BlockRangeZod, "XL1BlockRange");
 var toXL1BlockRange = zodToFactory15(XL1BlockRangeishZod, "XL1BlockRange");
 var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -896,29 +933,29 @@ function fromXL1BlockNumberKey(key, assert) {
 }
 
 // src/model/ChainQualification.ts
-var ChainQualificationZod = z21.object({ head: HashZod3, range: XL1BlockRangeZod });
+var ChainQualificationZod = z27.object({ head: HashZod3, range: XL1BlockRangeZod });
 var isChainQualification = zodIsFactory11(ChainQualificationZod);
-var ChainQualifiedRangeConfigZod = z21.object({ range: XL1BlockRangeZod });
+var ChainQualifiedRangeConfigZod = z27.object({ range: XL1BlockRangeZod });
 var isChainQualifiedRangeConfig = zodIsFactory11(ChainQualifiedRangeConfigZod);
-var ChainQualifiedHeadConfigZod = z21.object({ head: HashZod3 });
+var ChainQualifiedHeadConfigZod = z27.object({ head: HashZod3 });
 var isChainQualifiedHeadConfig = zodIsFactory11(ChainQualifiedHeadConfigZod);
-var ChainQualifiedConfigZod = z21.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z21.object({})]);
+var ChainQualifiedConfigZod = z27.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z27.object({})]);
 var isChainQualifiedConfig = zodIsFactory11(ChainQualifiedConfigZod);
 var ExtendChainQualifiedConfigZod = ((zodType) => {
-  return z21.union([
+  return z27.union([
     ChainQualifiedRangeConfigZod.extend(zodType),
     ChainQualifiedHeadConfigZod.extend(zodType),
     zodType
   ]);
 });
 var ChainQualifiedZod = (zodType) => {
-  return z21.tuple([zodType, ChainQualificationZod]);
+  return z27.tuple([zodType, ChainQualificationZod]);
 };
 
 // src/model/AccountBalance.ts
-var AccountBalanceHistoryItemZod = z22.tuple([
+var AccountBalanceHistoryItemZod = z28.tuple([
   WithHashMetaZod5(BlockBoundWitnessZod),
-  WithHashMetaZod5(TransactionBoundWitnessZod).nullable(),
+  z28.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
   WithHashMetaZod5(TransferZod)
 ]);
 var AccountBalanceQualificationZod = ChainQualificationZod;
@@ -939,7 +976,7 @@ var XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS = "0x319e667cED10452A117472811130444dE
 var XL1_ETH_MAIN_GOVERNANCE_ADDRESS = "0x7595710956d6B14b4f2F51a8dF41379eEeC9074E";
 
 // src/model/ArrayBuffer.ts
-import { z as z23 } from "zod";
+import { z as z29 } from "zod";
 function base64Encode(u8) {
   if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
     return Buffer.from(u8).toString("base64");
@@ -960,44 +997,44 @@ function base64Decode(b64) {
   for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i);
   return u8;
 }
-var ArrayBufferToJsonZod = z23.instanceof(ArrayBuffer).transform((x) => {
+var ArrayBufferToJsonZod = z29.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
 });
-var JsonToArrayBufferZod = z23.string().transform((x) => {
+var JsonToArrayBufferZod = z29.string().transform((x) => {
   const u8 = base64Decode(x);
   return u8.buffer;
 });
 
 // src/model/BlockRate.ts
 import { zodAsFactory as zodAsFactory16, zodIsFactory as zodIsFactory13 } from "@xylabs/sdk-js";
-import { z as z24 } from "zod";
-var TimeDurationsZod = z24.object({
-  millis: z24.number().nonnegative(),
-  seconds: z24.number().nonnegative(),
-  minutes: z24.number().nonnegative(),
-  hours: z24.number().nonnegative(),
-  days: z24.number().nonnegative(),
-  weeks: z24.number().nonnegative()
+import { z as z30 } from "zod";
+var TimeDurationsZod = z30.object({
+  millis: z30.number().nonnegative(),
+  seconds: z30.number().nonnegative(),
+  minutes: z30.number().nonnegative(),
+  hours: z30.number().nonnegative(),
+  days: z30.number().nonnegative(),
+  weeks: z30.number().nonnegative()
 });
 var isTimeDurations = zodIsFactory13(TimeDurationsZod);
 var asTimeDurations = zodAsFactory16(TimeDurationsZod, "asTimeDurations");
 var toTimeDurations = zodAsFactory16(TimeDurationsZod, "toTimeDurations");
-var BlockRateZod = z24.object({
+var BlockRateZod = z30.object({
   range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
-  rate: z24.number().nonnegative().describe("rate of blocks per specified time unit"),
+  rate: z30.number().nonnegative().describe("rate of blocks per specified time unit"),
   timeUnit: TimeDurationsZod.keyof().describe("the unit of time for the rate and timePerBlock"),
-  span: z24.int().nonnegative().describe("number of blocks the rate was calculated over"),
-  timeDifference: z24.number().nonnegative().describe("time difference from start and end block"),
-  timePerBlock: z24.number().nonnegative().describe("average time per block for the given range")
+  span: z30.int().nonnegative().describe("number of blocks the rate was calculated over"),
+  timeDifference: z30.number().nonnegative().describe("time difference from start and end block"),
+  timePerBlock: z30.number().nonnegative().describe("average time per block for the given range")
 });
 var isBlockRate = zodIsFactory13(BlockRateZod);
 var asBlockRate = zodAsFactory16(BlockRateZod, "asBlockRate");
 var toBlockRate = zodAsFactory16(BlockRateZod, "toBlockRate");
-var CountZod = z24.int().nonnegative().describe("A non-negative integer count");
-var StepIndexZod = z24.int().min(0).max(StepSizes.length).describe("A non-negative integer step index");
-var timeUnitSchema = z24.number().positive();
-var TimeConfigZod = z24.object({
+var CountZod = z30.int().nonnegative().describe("A non-negative integer count");
+var StepIndexZod = z30.int().min(0).max(StepSizes.length).describe("A non-negative integer step index");
+var timeUnitSchema = z30.number().positive();
+var TimeConfigZod = z30.object({
   minutes: timeUnitSchema.optional(),
   hours: timeUnitSchema.optional(),
   days: timeUnitSchema.optional(),
@@ -1008,30 +1045,30 @@ var TimeConfigZod = z24.object({
 var isTimeConfig = zodIsFactory13(TimeConfigZod);
 var asTimeConfig = zodAsFactory16(TimeConfigZod, "asTimeConfig");
 var toTimeConfig = zodAsFactory16(TimeConfigZod, "toTimeConfig");
-var SingleTimeConfigZod = z24.union([
-  z24.object({ minutes: timeUnitSchema }),
-  z24.object({ hours: timeUnitSchema }),
-  z24.object({ days: timeUnitSchema }),
-  z24.object({ weeks: timeUnitSchema }),
-  z24.object({ months: timeUnitSchema }),
-  z24.object({ years: timeUnitSchema })
+var SingleTimeConfigZod = z30.union([
+  z30.object({ minutes: timeUnitSchema }),
+  z30.object({ hours: timeUnitSchema }),
+  z30.object({ days: timeUnitSchema }),
+  z30.object({ weeks: timeUnitSchema }),
+  z30.object({ months: timeUnitSchema }),
+  z30.object({ years: timeUnitSchema })
 ]).describe("Time configuration with exactly one time unit");
 var isSingleTimeConfig = zodIsFactory13(SingleTimeConfigZod);
 var asSingleTimeConfig = zodAsFactory16(SingleTimeConfigZod, "asSingleTimeConfig");
 var toSingleTimeConfig = zodAsFactory16(SingleTimeConfigZod, "toSingleTimeConfig");
 
 // src/model/Context/BaseContext.zod.ts
-import { z as z25 } from "zod";
-var CachesZod = z25.record(
-  z25.string(),
-  z25.custom((val) => val && typeof val === "object" && ("get" in val || "set" in val))
+import { z as z31 } from "zod";
+var CachesZod = z31.record(
+  z31.string(),
+  z31.custom((val) => val && typeof val === "object" && ("get" in val || "set" in val))
 );
-var SingletonsZod = z25.record(z25.union([z25.string(), z25.symbol()]), z25.unknown());
-var LoggerZod = z25.custom((val) => val && typeof val === "object" && "info" in val && "error" in val);
-var MeterProviderZod = z25.custom((val) => val && typeof val === "object" && "getMeter" in val);
-var TracerProviderZod = z25.custom((val) => val && typeof val === "object" && "getTracer" in val);
-var TimeBudgetLimitZod = z25.number();
-var BaseContextZod = z25.object({
+var SingletonsZod = z31.record(z31.union([z31.string(), z31.symbol()]), z31.unknown());
+var LoggerZod = z31.custom((val) => val && typeof val === "object" && "info" in val && "error" in val);
+var MeterProviderZod = z31.custom((val) => val && typeof val === "object" && "getMeter" in val);
+var TracerProviderZod = z31.custom((val) => val && typeof val === "object" && "getTracer" in val);
+var TimeBudgetLimitZod = z31.number();
+var BaseContextZod = z31.object({
   caches: CachesZod.optional(),
   logger: LoggerZod.optional(),
   meterProvider: MeterProviderZod.optional(),
@@ -1041,24 +1078,24 @@ var BaseContextZod = z25.object({
 });
 
 // src/model/Context/BlockContext.zod.ts
-import z26 from "zod";
+import z32 from "zod";
 
 // src/model/Context/CachingContext.zod.ts
 var CachingContextZod = BaseContextZod.extend({ caches: CachesZod });
 
 // src/model/Context/BlockContext.zod.ts
 var BlockContextReadZod = CachingContextZod.extend(
-  { chainMap: z26.custom((val) => val && typeof val === "object" && "get" in val) }
+  { chainMap: z32.custom((val) => val && typeof val === "object" && "get" in val) }
 );
 var BlockContextWriteZod = CachingContextZod.extend(
-  { chainMap: z26.custom((val) => val && typeof val === "object" && ("get" in val && "insert" in val)) }
+  { chainMap: z32.custom((val) => val && typeof val === "object" && ("get" in val && "insert" in val)) }
 );
 var BlockContextZod = BlockContextWriteZod;
 
 // src/model/Context/HeadContext.zod.ts
 import { WithHashMetaZod as WithHashMetaZod6 } from "@xyo-network/sdk-js";
-import z27 from "zod";
-var HeadContextBaseZod = z27.object(
+import z33 from "zod";
+var HeadContextBaseZod = z33.object(
   { head: WithHashMetaZod6(BlockBoundWitnessZod) }
 );
 var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
@@ -1103,45 +1140,45 @@ import {
   WithHashMetaZod as WithHashMetaZod7,
   WithStorageMetaZod as WithStorageMetaZod5
 } from "@xyo-network/sdk-js";
-import { z as z28 } from "zod";
-var HydratedTransactionZod = z28.tuple([
+import { z as z34 } from "zod/mini";
+var HydratedTransactionZod = z34.tuple([
   TransactionBoundWitnessZod,
-  z28.array(PayloadZodLoose2)
+  z34.array(PayloadZodLoose2)
 ]);
 var isHydratedTransaction = zodIsFactory14(HydratedTransactionZod);
 var asHydratedTransaction = zodAsFactory17(HydratedTransactionZod, "asHydratedTransaction");
 var toHydratedTransaction = zodToFactory16(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z28.tuple([
+var HydratedTransactionWithHashMetaZod = z34.tuple([
   WithHashMetaZod7(TransactionBoundWitnessZod),
-  z28.array(WithHashMetaZod7(PayloadZod2).loose())
+  z34.array(z34.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isHydratedTransactionWithHashMeta = zodIsFactory14(HydratedTransactionWithHashMetaZod);
 var asHydratedTransactionWithHashMeta = zodAsFactory17(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
 var toHydratedTransactionWithHashMeta = zodToFactory16(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z28.tuple([
+var HydratedTransactionWithStorageMetaZod = z34.tuple([
   WithStorageMetaZod5(TransactionBoundWitnessZod),
-  z28.array(WithStorageMetaZod5(PayloadZod2).loose())
+  z34.array(z34.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isHydratedTransactionWithStorageMeta = zodIsFactory14(HydratedTransactionWithStorageMetaZod);
 var asHydratedTransactionWithStorageMeta = zodAsFactory17(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
 var toHydratedTransactionWithStorageMeta = zodToFactory16(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z28.tuple([
+var UnsignedHydratedTransactionZod = z34.tuple([
   UnsignedTransactionBoundWitnessZod,
-  z28.array(PayloadZodLoose2)
+  z34.array(PayloadZodLoose2)
 ]);
 var isUnsignedHydratedTransaction = zodIsFactory14(UnsignedHydratedTransactionZod);
 var asUnsignedHydratedTransaction = zodAsFactory17(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
 var toUnsignedHydratedTransaction = zodToFactory16(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z28.tuple([
+var UnsignedHydratedTransactionWithHashMetaZod = z34.tuple([
   WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
-  z28.array(WithHashMetaZod7(PayloadZod2).loose())
+  z34.array(z34.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory14(UnsignedHydratedTransactionWithHashMetaZod);
 var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory17(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
 var toUnsignedHydratedTransactionWithHashMeta = zodToFactory16(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z28.tuple([
+var UnsignedHydratedTransactionWithStorageMetaZod = z34.tuple([
   WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
-  z28.array(WithStorageMetaZod5(PayloadZod2).loose())
+  z34.array(z34.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory14(UnsignedHydratedTransactionWithStorageMetaZod);
 var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory17(
@@ -1152,23 +1189,23 @@ var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory16(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z28.tuple([
+var SignedHydratedTransactionZod = z34.tuple([
   SignedTransactionBoundWitnessZod,
-  z28.array(PayloadZodLoose2)
+  z34.array(PayloadZodLoose2)
 ]);
 var isSignedHydratedTransaction = zodIsFactory14(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory17(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var toSignedHydratedTransaction = zodToFactory16(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z28.tuple([
+var SignedHydratedTransactionWithHashMetaZod = z34.tuple([
   WithHashMetaZod7(SignedTransactionBoundWitnessZod),
-  z28.array(WithHashMetaZod7(PayloadZod2).loose())
+  z34.array(z34.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
 var isSignedHydratedTransactionWithHashMeta = zodIsFactory14(SignedHydratedTransactionWithHashMetaZod);
 var asSignedHydratedTransactionWithHashMeta = zodAsFactory17(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
 var toSignedHydratedTransactionWithHashMeta = zodToFactory16(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z28.tuple([
+var SignedHydratedTransactionWithStorageMetaZod = z34.tuple([
   WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
-  z28.array(WithStorageMetaZod5(PayloadZod2).loose())
+  z34.array(z34.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
 var isSignedHydratedTransactionWithStorageMeta = zodIsFactory14(SignedHydratedTransactionWithStorageMetaZod);
 var asSignedHydratedTransactionWithStorageMeta = zodAsFactory17(
@@ -1184,22 +1221,22 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory16(
 var ELEVATE_OPCODE = "elevate";
 
 // src/model/Permission.ts
-import { z as z29 } from "zod";
-var CaveatTypesZod = z29.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z29.object({
+import { z as z35 } from "zod";
+var CaveatTypesZod = z35.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z35.object({
   type: CaveatTypesZod,
-  value: z29.json()
+  value: z35.json()
 });
-var PermissionZod = z29.object({
-  parentCapability: z29.string(),
+var PermissionZod = z35.object({
+  parentCapability: z35.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z29.string()
+  invoker: z35.string()
 });
-var InvokerPermissionZod = PermissionZod.safeExtend({ date: z29.number().optional() });
-var PermissionRequestZod = z29.record(z29.string(), z29.record(z29.string(), z29.any()));
-var RequestedPermissionZod = z29.object({
-  parentCapability: z29.string(),
-  date: z29.number().optional()
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z35.number().optional() });
+var PermissionRequestZod = z35.record(z35.string(), z35.record(z35.string(), z35.any()));
+var RequestedPermissionZod = z35.object({
+  parentCapability: z35.string(),
+  date: z35.number().optional()
 });
 
 // src/model/rewards.ts
@@ -1214,44 +1251,44 @@ var XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20000000000n, XL1_REWARD
 
 // src/model/RewardsRangeOptions.ts
 import { AddressZod as AddressZod3 } from "@xylabs/sdk-js";
-import { z as z30 } from "zod";
-var RewardsRangeOptionsZod = z30.object({
-  positions: z30.array(z30.number()).optional(),
+import { z as z36 } from "zod";
+var RewardsRangeOptionsZod = z36.object({
+  positions: z36.array(z36.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z30.array(StepIdentityZod).optional(),
-  stakers: z30.array(AddressZod3).optional()
+  steps: z36.array(StepIdentityZod).optional(),
+  stakers: z36.array(AddressZod3).optional()
 });
 
 // src/model/Sequence.ts
 import { HexRegExMinMax, toHex } from "@xylabs/sdk-js";
 import { SequenceConstants } from "@xyo-network/sdk-js";
-import { z as z31 } from "zod";
+import { z as z37 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z31.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z31.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z37.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z37.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z31.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z31.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z31.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z31.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+var QualifiedSequenceToStringZod = z37.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z37.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z37.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z37.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
 
 // src/model/Stake.ts
 import { AddressZod as AddressZod4, HexZod as HexZod6 } from "@xylabs/sdk-js";
-import { z as z32 } from "zod";
-var StakeZod = z32.object({
+import { z as z38 } from "zod";
+var StakeZod = z38.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z32.number(),
+  addBlock: z38.number(),
   // the unique id for the stake item
-  id: z32.number(),
+  id: z38.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z32.number(),
+  removeBlock: z38.number(),
   // the address that is being staked
   staked: AddressZod4,
   // the address that owns the stake
   staker: AddressZod4,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z32.number()
+  withdrawBlock: z38.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
@@ -1273,17 +1310,17 @@ var JsonToStakeZod = StakeZod.extend({ amount: HexZod6 }).transform((val) => ({
 }));
 
 // src/model/TimeDomain.ts
-import { z as z33 } from "zod";
-var TimeDomainZod = z33.union([
-  z33.literal("xl1"),
-  z33.literal("epoch"),
-  z33.literal("ethereum")
+import { z as z39 } from "zod";
+var TimeDomainZod = z39.union([
+  z39.literal("xl1"),
+  z39.literal("epoch"),
+  z39.literal("ethereum")
 ]);
 
 // src/model/TransferPair.ts
 import { AddressZod as AddressZod5 } from "@xylabs/sdk-js";
-import { z as z34 } from "zod";
-var TransferPairZod = z34.tuple([
+import { z as z40 } from "zod";
+var TransferPairZod = z40.tuple([
   AddressZod5,
   AddressZod5
 ]);
@@ -1310,25 +1347,28 @@ import {
   isPayloadOfSchemaType as isPayloadOfSchemaType7,
   PayloadZodOfSchema as PayloadZodOfSchema3
 } from "@xyo-network/sdk-js";
-import { z as z36 } from "zod";
+import { z as z42 } from "zod/mini";
 
 // src/rejection/RejectionError.ts
 import { HashZod as HashZod4 } from "@xylabs/sdk-js";
-import { z as z35 } from "zod";
-var RejectionErrorZod = z35.object({
+import { z as z41 } from "zod";
+var RejectionErrorZod = z41.object({
   hash: HashZod4,
-  message: z35.string().optional(),
-  name: z35.string()
+  message: z41.string().optional(),
+  name: z41.string()
 }).loose();
 
 // src/rejection/BlockRejectionPayload.ts
 var BlockRejectionSchema = asSchema11("network.xyo.block.rejection", true);
-var BlockRejectionFieldsZod = z36.object({
+var BlockRejectionFieldsZod = z42.object({
   block: HydratedBlockZod,
-  errors: z36.array(RejectionErrorZod),
-  rejector: z36.string()
+  errors: z42.array(RejectionErrorZod),
+  rejector: z42.string()
 });
-var BlockRejectionZod = PayloadZodOfSchema3(BlockRejectionSchema).extend(BlockRejectionFieldsZod.shape);
+var BlockRejectionZod = z42.extend(
+  PayloadZodOfSchema3(BlockRejectionSchema),
+  BlockRejectionFieldsZod.shape
+);
 var isBlockRejection = isPayloadOfSchemaType7(BlockRejectionSchema);
 var asBlockRejection = AsObjectFactory11.create(isBlockRejection);
 
@@ -1339,14 +1379,17 @@ import {
   isPayloadOfSchemaType as isPayloadOfSchemaType8,
   PayloadZodOfSchema as PayloadZodOfSchema4
 } from "@xyo-network/sdk-js";
-import { z as z37 } from "zod";
+import { z as z43 } from "zod/mini";
 var TransactionRejectionSchema = asSchema12("network.xyo.transaction.rejection", true);
-var TransactionRejectionFieldsZod = z37.object({
-  errors: z37.array(RejectionErrorZod),
-  rejector: z37.string(),
+var TransactionRejectionFieldsZod = z43.object({
+  errors: z43.array(RejectionErrorZod),
+  rejector: z43.string(),
   transaction: HydratedTransactionZod
 });
-var TransactionRejectionZod = PayloadZodOfSchema4(TransactionRejectionSchema).extend(TransactionRejectionFieldsZod.shape);
+var TransactionRejectionZod = z43.extend(
+  PayloadZodOfSchema4(TransactionRejectionSchema),
+  TransactionRejectionFieldsZod.shape
+);
 var isTransactionRejection = isPayloadOfSchemaType8(TransactionRejectionSchema);
 var asTransactionRejection = AsObjectFactory12.create(isTransactionRejection);
 export {