@xyo-network/xl1-protocol 1.14.8 → 1.14.10

package/dist/neutral/index.mjs

@@ -285,10 +285,10 @@ var XL1Amount = class _XL1Amount {
 
 // src/block/AllowedBlockPayload.ts
 import { zodIsFactory as zodIsFactory7 } from "@xylabs/zod";
-import { BoundWitnessSchema as BoundWitnessSchema2 } from "@xyo-network/boundwitness-model";
+import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
 import { isHashMeta } from "@xyo-network/payload-model";
 import { isSchemaPayload, SchemaSchema } from "@xyo-network/schema-payload-plugin";
-import z29 from "zod";
+import z28 from "zod";
 
 // src/payload/elevatable/Bridge/BridgeDestinationObservation.ts
 import { HexZod as HexZod2 } from "@xylabs/hex";
@@ -498,27 +498,27 @@ var NumberishZod = z6.union([z6.number(), z6.string(), z6.bigint()]).transform((
 
 // src/model/BlockNumber/BlockNumber.ts
 var BlockNumberZod = z7.number().transform((v) => v);
-var NumberishBlockNumberZod = NumberishZod.transform((v) => v);
+var BlockNumberishZod = NumberishZod.transform((v) => v);
 var asBlockNumber = zodAsFactory(BlockNumberZod, "asBlockNumber");
-var toBlockNumber = zodToFactory(NumberishBlockNumberZod, "toBlockNumber");
+var toBlockNumber = zodToFactory(BlockNumberishZod, "toBlockNumber");
 var BLOCK_NUMBER_ZERO = asBlockNumber(0);
 
 // src/model/BlockNumber/EthBlockNumber.ts
 import { zodAsFactory as zodAsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/zod";
 import z8 from "zod";
 var EthBlockNumberZod = z8.number().transform((v) => v);
-var NumberishEthBlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
+var EthBlockNumberishZod = BlockNumberishZod.transform((v) => v);
 var asEthBlockNumber = zodAsFactory2(EthBlockNumberZod, "asEthBlockNumber");
-var toEthBlockNumber = zodToFactory2(NumberishEthBlockNumberZod, "toEthBlockNumber");
+var toEthBlockNumber = zodToFactory2(EthBlockNumberishZod, "toEthBlockNumber");
 var ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0);
 
 // src/model/BlockNumber/XL1BlockNumber.ts
 import { zodAsFactory as zodAsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/zod";
 import z9 from "zod";
 var XL1BlockNumberZod = z9.number().transform((v) => v);
-var NumberishXL1BlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
+var XL1BlockNumberishZod = BlockNumberishZod.transform((v) => v);
 var asXL1BlockNumber = zodAsFactory3(XL1BlockNumberZod, "asXL1BlockNumber");
-var toXL1BlockNumber = zodToFactory3(NumberishXL1BlockNumberZod, "toXL1BlockNumber");
+var toXL1BlockNumber = zodToFactory3(XL1BlockNumberishZod, "toXL1BlockNumber");
 var XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0);
 
 // src/model/BlockRange/BlockRange.ts
@@ -527,9 +527,9 @@ import { isDefined } from "@xylabs/typeof";
 import { zodAsFactory as zodAsFactory4, zodToFactory as zodToFactory4 } from "@xylabs/zod";
 import z10 from "zod";
 var BlockRangeZod = z10.tuple([BlockNumberZod, BlockNumberZod]);
-var NumberishBlockRangeZod = z10.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod]);
+var BlockRangeishZod = z10.tuple([BlockNumberishZod, BlockNumberishZod]);
 var asBlockRange = zodAsFactory4(BlockRangeZod, "BlockRange");
-var toBlockRange = zodToFactory4(NumberishBlockRangeZod, "BlockRange");
+var toBlockRange = zodToFactory4(BlockRangeishZod, "BlockRange");
 var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
 function fromBlockNumberKey(key, assert) {
   const [start, end] = key.split("|").map((v) => asBlockNumber(Number(v)));
@@ -543,9 +543,9 @@ import { isDefined as isDefined2 } from "@xylabs/typeof";
 import { zodAsFactory as zodAsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/zod";
 import z11 from "zod";
 var EthBlockRangeZod = z11.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-var NumberishEthBlockRangeZod = z11.tuple([NumberishEthBlockNumberZod, NumberishEthBlockNumberZod]);
+var EthBlockRangeishZod = z11.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
 var asEthBlockRange = zodAsFactory5(EthBlockRangeZod, "EthBlockRange");
-var toEthBlockRange = zodToFactory5(NumberishEthBlockRangeZod, "EthBlockRange");
+var toEthBlockRange = zodToFactory5(EthBlockRangeishZod, "EthBlockRange");
 var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
 function fromEthBlockNumberKey(key, assert) {
   const [start, end] = key.split("|").map((v) => asEthBlockNumber(Number(v)));
@@ -571,9 +571,9 @@ import { isDefined as isDefined3 } from "@xylabs/typeof";
 import { zodAsFactory as zodAsFactory7, zodToFactory as zodToFactory7 } from "@xylabs/zod";
 import z13 from "zod";
 var XL1BlockRangeZod = z13.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-var NumberishXL1BlockRangeZod = z13.tuple([NumberishXL1BlockNumberZod, NumberishXL1BlockNumberZod]);
+var XL1BlockRangeishZod = z13.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
 var asXL1BlockRange = zodAsFactory7(XL1BlockRangeZod, "XL1BlockRange");
-var toXL1BlockRange = zodToFactory7(NumberishXL1BlockRangeZod, "XL1BlockRange");
+var toXL1BlockRange = zodToFactory7(XL1BlockRangeishZod, "XL1BlockRange");
 var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
 function fromXL1BlockNumberKey(key, assert) {
   const [start, end] = key.split("|").map((v) => asXL1BlockNumber(Number(v)));
@@ -647,86 +647,55 @@ var JsonToArrayBufferZod = z15.string().transform((x) => {
 });
 
 // src/zod/BlockBoundWitness.ts
-import { HashZod as HashZod3 } from "@xylabs/sdk-js";
+import { HashZod as HashZod2 } from "@xylabs/sdk-js";
 import {
   zodAsFactory as zodAsFactory8,
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory8
 } from "@xylabs/zod";
-import { HashMetaZod, StorageMetaZod as StorageMetaZod2 } from "@xyo-network/payload-model";
-import * as z18 from "zod";
-
-// src/zod/BoundWitness.ts
 import {
-  AddressZod as AddressZod2,
-  HashZod as HashZod2,
-  HexZod as HexZod5
-} from "@xylabs/sdk-js";
-import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
-import {
-  PayloadZod as PayloadZod2,
-  SchemaZod,
-  StorageMetaZod
-} from "@xyo-network/payload-model";
-import * as z16 from "zod";
-var BoundWitnessRequiredFieldsZod = z16.object({
-  addresses: z16.array(AddressZod2),
-  payload_hashes: z16.array(HashZod2),
-  payload_schemas: z16.array(SchemaZod),
-  previous_hashes: z16.array(HashZod2.nullable())
-});
-var BoundWitnessMetaZod = z16.object({
-  $destination: AddressZod2.optional(),
-  $sourceQuery: HashZod2.optional(),
-  $signatures: z16.array(z16.union([HexZod5, z16.null()]))
-});
-var BoundWitnessZod = PayloadZod2.extend({ schema: z16.literal(BoundWitnessSchema) }).extend(BoundWitnessRequiredFieldsZod.shape).extend(BoundWitnessMetaZod.shape).refine((data) => data.$signatures.length === data.addresses.length, { message: "$signatures length must equal addresses length" });
-var AnyBoundWitnessZod = BoundWitnessZod.catchall(z16.any());
-var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.includes(null), { message: "all $signatures must be null" });
-var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z16.any());
-var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape).safeExtend(StorageMetaZod.shape);
-var SignedZod = z16.object({ $signatures: z16.array(HexZod5) });
-var UnsignedZod = z16.object({ $signatures: z16.array(z16.null()) });
-var SignedBoundWitnessZod = BoundWitnessZod.refine((data) => !data.$signatures.includes(null), { message: "all $signatures must not be null" });
-var SignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod;
-var AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z16.any());
-var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z16.any());
+  BoundWitnessZod,
+  SignedBoundWitnessZod,
+  UnsignedBoundWitnessZod
+} from "@xyo-network/boundwitness-model";
+import { HashMetaZod, StorageMetaZod } from "@xyo-network/payload-model";
+import * as z17 from "zod";
 
 // src/zod/Chain.ts
 import { AddressRegEx, toAddress } from "@xylabs/sdk-js";
-import * as z17 from "zod";
-var ChainZod = z17.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
+import * as z16 from "zod";
+var ChainZod = z16.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
 // src/zod/BlockBoundWitness.ts
-var BlockBoundWitnessFieldsZod = z18.object({
+var BlockBoundWitnessFieldsZod = z17.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: HashZod3.nullable(),
-  protocol: z18.number(),
-  step_hashes: z18.array(HashZod3).optional()
+  previous: HashZod2.nullable(),
+  protocol: z17.number(),
+  step_hashes: z17.array(HashZod2).optional()
 });
-var BlockBoundWitnessMetaZod = z18.object({ $epoch: z18.number() });
-var BlockBoundWitnessZod = BoundWitnessZod.extend(BlockBoundWitnessFieldsZod.shape).extend(BlockBoundWitnessMetaZod.shape);
+var BlockBoundWitnessMetaZod = z17.object({ $epoch: z17.number() });
+var BlockBoundWitnessZod = BoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
 var isBlockBoundWitness = zodIsFactory2(BlockBoundWitnessZod);
 var asBlockBoundWitness = zodAsFactory8(BlockBoundWitnessZod, "asBlockBoundWitness");
 var toBlockBoundWitness = zodToFactory8(BlockBoundWitnessZod, "toBlockBoundWitness");
-var BlockBoundWitnessWithHashMetaZod = BlockBoundWitnessZod.extend(HashMetaZod.shape);
+var BlockBoundWitnessWithHashMetaZod = BlockBoundWitnessZod.safeExtend(HashMetaZod.shape);
 var isBlockBoundWitnessWithHashMeta = zodIsFactory2(BlockBoundWitnessWithHashMetaZod);
 var asBlockBoundWitnessWithHashMeta = zodAsFactory8(BlockBoundWitnessWithHashMetaZod, "asBlockBoundWitnessWithHashMeta");
 var toBlockBoundWitnessWithHashMeta = zodToFactory8(BlockBoundWitnessWithHashMetaZod, "toBlockBoundWitnessWithHashMeta");
-var BlockBoundWitnessWithStorageMetaZod = BlockBoundWitnessZod.extend(StorageMetaZod2.shape);
+var BlockBoundWitnessWithStorageMetaZod = BlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
 var isBlockBoundWitnessWithStorageMeta = zodIsFactory2(BlockBoundWitnessWithStorageMetaZod);
 var asBlockBoundWitnessWithStorageMeta = zodAsFactory8(BlockBoundWitnessWithStorageMetaZod, "asBlockBoundWitnessWithStorageMeta");
 var toBlockBoundWitnessWithStorageMeta = zodToFactory8(BlockBoundWitnessWithStorageMetaZod, "toBlockBoundWitnessWithStorageMeta");
-var UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod.extend(BlockBoundWitnessFieldsZod.shape).extend(BlockBoundWitnessMetaZod.shape);
+var UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
 var isUnsignedBlockBoundWitness = zodIsFactory2(UnsignedBlockBoundWitnessZod);
 var asUnsignedBlockBoundWitness = zodAsFactory8(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
 var toUnsignedBlockBoundWitness = zodToFactory8(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
-var UnsignedBlockBoundWitnessWithHashMetaZod = UnsignedBlockBoundWitnessZod.extend(HashMetaZod.shape);
+var UnsignedBlockBoundWitnessWithHashMetaZod = UnsignedBlockBoundWitnessZod.safeExtend(HashMetaZod.shape);
 var isUnsignedBlockBoundWitnessWithHashMeta = zodIsFactory2(UnsignedBlockBoundWitnessWithHashMetaZod);
 var asUnsignedBlockBoundWitnessWithHashMeta = zodAsFactory8(UnsignedBlockBoundWitnessWithHashMetaZod, "asUnsignedBlockBoundWitnessWithHashMeta");
 var toUnsignedBlockBoundWitnessWithHashMeta = zodToFactory8(UnsignedBlockBoundWitnessWithHashMetaZod, "toUnsignedBlockBoundWitnessWithHashMeta");
-var UnsignedBlockBoundWitnessWithStorageMetaZod = UnsignedBlockBoundWitnessZod.extend(StorageMetaZod2.shape);
+var UnsignedBlockBoundWitnessWithStorageMetaZod = UnsignedBlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
 var isUnsignedBlockBoundWitnessWithStorageMeta = zodIsFactory2(UnsignedBlockBoundWitnessWithStorageMetaZod);
 var asUnsignedBlockBoundWitnessWithStorageMeta = zodAsFactory8(
   UnsignedBlockBoundWitnessWithStorageMetaZod,
@@ -736,15 +705,15 @@ var toUnsignedBlockBoundWitnessWithStorageMeta = zodToFactory8(
   UnsignedBlockBoundWitnessWithStorageMetaZod,
   "toUnsignedBlockBoundWitnessWithStorageMeta"
 );
-var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.extend(BlockBoundWitnessFieldsZod.shape).extend(BlockBoundWitnessMetaZod.shape);
+var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
 var isSignedBlockBoundWitness = zodIsFactory2(SignedBlockBoundWitnessZod);
 var asSignedBlockBoundWitness = zodAsFactory8(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
 var toSignedBlockBoundWitness = zodToFactory8(SignedBlockBoundWitnessZod, "toSignedBlockBoundWitness");
-var SignedBlockBoundWitnessWithHashMetaZod = SignedBlockBoundWitnessZod.extend(HashMetaZod.shape);
+var SignedBlockBoundWitnessWithHashMetaZod = SignedBlockBoundWitnessZod.safeExtend(HashMetaZod.shape);
 var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory2(SignedBlockBoundWitnessWithHashMetaZod);
 var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory8(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
 var toSignedBlockBoundWitnessWithHashMeta = zodToFactory8(SignedBlockBoundWitnessWithHashMetaZod, "toSignedBlockBoundWitnessWithHashMeta");
-var SignedBlockBoundWitnessWithStorageMetaZod = SignedBlockBoundWitnessZod.extend(StorageMetaZod2.shape);
+var SignedBlockBoundWitnessWithStorageMetaZod = SignedBlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
 var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory2(SignedBlockBoundWitnessWithStorageMetaZod);
 var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory8(
   SignedBlockBoundWitnessWithStorageMetaZod,
@@ -766,52 +735,52 @@ import {
   WithHashMetaZod,
   WithStorageMetaZod
 } from "@xyo-network/payload-model";
-import * as z19 from "zod";
-var HydratedBlockZod = z19.tuple([
+import * as z18 from "zod";
+var HydratedBlockZod = z18.tuple([
   BlockBoundWitnessZod,
-  z19.array(PayloadZodLoose)
+  z18.array(PayloadZodLoose)
 ]);
 var isHydratedBlock = zodIsFactory3(HydratedBlockZod);
 var asHydratedBlock = zodAsFactory9(HydratedBlockZod, "asHydratedBlock");
 var toHydratedBlock = zodToFactory9(HydratedBlockZod, "toHydratedBlock");
-var HydratedBlockWithHashMetaZod = z19.tuple([
+var HydratedBlockWithHashMetaZod = z18.tuple([
   WithHashMetaZod(BlockBoundWitnessZod),
-  z19.array(WithHashMetaZod(PayloadZodLoose))
+  z18.array(WithHashMetaZod(PayloadZodLoose))
 ]);
 var isHydratedBlockWithHashMeta = zodIsFactory3(HydratedBlockWithHashMetaZod);
 var asHydratedBlockWithHashMeta = zodAsFactory9(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
 var toHydratedBlockWithHashMeta = zodToFactory9(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
-var HydratedBlockWithStorageMetaZod = z19.tuple([
+var HydratedBlockWithStorageMetaZod = z18.tuple([
   WithStorageMetaZod(BlockBoundWitnessZod),
-  z19.array(WithStorageMetaZod(PayloadZodLoose))
+  z18.array(WithStorageMetaZod(PayloadZodLoose))
 ]);
 var isHydratedBlockWithStorageMeta = zodIsFactory3(HydratedBlockWithStorageMetaZod);
 var asHydratedBlockWithStorageMeta = zodAsFactory9(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
 var toHydratedBlockWithStorageMeta = zodToFactory9(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
-var SignedHydratedBlockZod = z19.tuple([
+var SignedHydratedBlockZod = z18.tuple([
   SignedBlockBoundWitnessZod,
-  z19.array(PayloadZodLoose)
+  z18.array(PayloadZodLoose)
 ]);
 var isSignedHydratedBlock = zodIsFactory3(SignedHydratedBlockZod);
 var asSignedHydratedBlock = zodAsFactory9(SignedHydratedBlockZod, "asSignedHydratedBlock");
 var toSignedHydratedBlock = zodToFactory9(SignedHydratedBlockZod, "toSignedHydratedBlock");
-var SignedHydratedBlockToJsonZod = z19.tuple([
+var SignedHydratedBlockToJsonZod = z18.tuple([
   SignedBlockBoundWitnessZod,
-  z19.array(PayloadZodLoose)
+  z18.array(PayloadZodLoose)
 ]);
 var isSignedHydratedBlockToJson = zodIsFactory3(SignedHydratedBlockToJsonZod);
 var asSignedHydratedBlockToJson = zodAsFactory9(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
 var toSignedHydratedBlockToJson = zodToFactory9(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
-var SignedHydratedBlockWithHashMetaZod = z19.tuple([
+var SignedHydratedBlockWithHashMetaZod = z18.tuple([
   WithHashMetaZod(SignedBlockBoundWitnessZod),
-  z19.array(WithHashMetaZod(PayloadZodLoose))
+  z18.array(WithHashMetaZod(PayloadZodLoose))
 ]);
 var isSignedHydratedBlockWithHashMeta = zodIsFactory3(SignedHydratedBlockWithHashMetaZod);
 var asSignedHydratedBlockWithHashMeta = zodAsFactory9(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
 var toSignedHydratedBlockWithHashMeta = zodToFactory9(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
-var SignedHydratedBlockWithStorageMetaZod = z19.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z18.tuple([
   WithStorageMetaZod(SignedBlockBoundWitnessZod),
-  z19.array(WithStorageMetaZod(PayloadZodLoose))
+  z18.array(WithStorageMetaZod(PayloadZodLoose))
 ]);
 
 // src/zod/HydratedTransaction.ts
@@ -821,27 +790,31 @@ import {
   zodToFactory as zodToFactory12
 } from "@xylabs/zod";
 import {
-  asAnyPayload,
   PayloadZodLoose as PayloadZodLoose2,
   WithHashMetaZod as WithHashMetaZod2,
   WithStorageMetaZod as WithStorageMetaZod2
 } from "@xyo-network/payload-model";
-import * as z22 from "zod";
+import * as z21 from "zod";
 
 // src/zod/TransactionBoundWitness.ts
-import { AddressZod as AddressZod3 } from "@xylabs/sdk-js";
+import { AddressZod as AddressZod2 } from "@xylabs/sdk-js";
 import {
   zodAsFactory as zodAsFactory11,
   zodIsFactory as zodIsFactory5,
   zodToFactory as zodToFactory11
 } from "@xylabs/zod";
-import { HashMetaZod as HashMetaZod2, StorageMetaZod as StorageMetaZod3 } from "@xyo-network/payload-model";
-import * as z21 from "zod";
+import {
+  BoundWitnessZod as BoundWitnessZod2,
+  SignedBoundWitnessZod as SignedBoundWitnessZod2,
+  UnsignedBoundWitnessZod as UnsignedBoundWitnessZod2
+} from "@xyo-network/boundwitness-model";
+import { HashMetaZod as HashMetaZod2, StorageMetaZod as StorageMetaZod2 } from "@xyo-network/payload-model";
+import * as z20 from "zod";
 
 // src/zod/TransactionFees.ts
 import {
   BigIntToJsonZod,
-  HexZod as HexZod6,
+  HexZod as HexZod5,
   JsonToBigIntZod
 } from "@xylabs/sdk-js";
 import {
@@ -849,20 +822,20 @@ import {
   zodIsFactory as zodIsFactory4,
   zodToFactory as zodToFactory10
 } from "@xylabs/zod";
-import * as z20 from "zod";
-var AttoZod = z20.bigint();
+import * as z19 from "zod";
+var AttoZod = z19.bigint();
 var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
 var AttoToJsonZod = BigIntToJsonZod;
-var TransactionFeesHexZod = z20.object({
-  base: HexZod6,
-  gasLimit: HexZod6,
-  gasPrice: HexZod6,
-  priority: HexZod6
+var TransactionFeesHexZod = z19.object({
+  base: HexZod5,
+  gasLimit: HexZod5,
+  gasPrice: HexZod5,
+  priority: HexZod5
 });
 var isTransactionFeesHex = zodIsFactory4(TransactionFeesHexZod);
 var asTransactionFeesHex = zodAsFactory10(TransactionFeesHexZod, "asTransactionFeesHex");
 var toTransactionFeesHex = zodToFactory10(TransactionFeesHexZod, "toTransactionFeesHex");
-var TransactionFeesBigIntZod = z20.object({
+var TransactionFeesBigIntZod = z19.object({
   base: AttoZod,
   gasLimit: AttoZod,
   gasPrice: AttoZod,
@@ -885,30 +858,30 @@ var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) =>
 }));
 
 // src/zod/TransactionBoundWitness.ts
-var BlockStartZod = z21.object({ nbf: BlockNumberZod });
-var BlockEndZod = z21.object({ exp: BlockNumberZod });
-var BlockDurationZod = z21.object({ nbf: BlockNumberZod, exp: BlockNumberZod });
-var BlockScriptsZod = z21.object({ script: z21.array(z21.string()).optional() });
-var TransactionFeesZod = z21.object({ fees: TransactionFeesHexZod });
-var TransactionBoundWitnessIdentityFields = z21.object({ chain: ChainZod, from: AddressZod3 });
-var TransactionBoundWitnessFieldsZod = z21.object().extend(BlockDurationZod.shape).extend(TransactionFeesZod.shape).extend(TransactionBoundWitnessIdentityFields.shape).extend(BlockScriptsZod.shape);
-var TransactionBoundWitnessZod = BoundWitnessZod.extend(TransactionBoundWitnessFieldsZod.shape);
+var BlockStartZod = z20.object({ nbf: XL1BlockNumberZod });
+var BlockEndZod = z20.object({ exp: XL1BlockNumberZod });
+var BlockDurationZod = z20.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod });
+var BlockScriptsZod = z20.object({ script: z20.array(z20.string()).optional() });
+var TransactionFeesZod = z20.object({ fees: TransactionFeesHexZod });
+var TransactionBoundWitnessIdentityFields = z20.object({ chain: ChainZod, from: AddressZod2 });
+var TransactionBoundWitnessFieldsZod = z20.object().safeExtend(BlockDurationZod.shape).safeExtend(TransactionFeesZod.shape).safeExtend(TransactionBoundWitnessIdentityFields.shape).safeExtend(BlockScriptsZod.shape);
+var TransactionBoundWitnessZod = BoundWitnessZod2.safeExtend(TransactionBoundWitnessFieldsZod.shape);
 var isTransactionBoundWitness = zodIsFactory5(TransactionBoundWitnessZod);
 var asTransactionBoundWitness = zodAsFactory11(TransactionBoundWitnessZod, "asTransactionBoundWitness");
 var toTransactionBoundWitness = zodToFactory11(TransactionBoundWitnessZod, "toTransactionBoundWitness");
-var TransactionBoundWitnessWithHashMetaZod = TransactionBoundWitnessZod.extend(HashMetaZod2.shape);
+var TransactionBoundWitnessWithHashMetaZod = TransactionBoundWitnessZod.safeExtend(HashMetaZod2.shape);
 var isTransactionBoundWitnessWithHashMeta = zodIsFactory5(TransactionBoundWitnessWithHashMetaZod);
 var asTransactionBoundWitnessWithHashMeta = zodAsFactory11(TransactionBoundWitnessWithHashMetaZod, "asTransactionBoundWitnessWithHashMeta");
 var toTransactionBoundWitnessWithHashMeta = zodToFactory11(TransactionBoundWitnessWithHashMetaZod, "toTransactionBoundWitnessWithHashMeta");
-var TransactionBoundWitnessWithStorageMetaZod = TransactionBoundWitnessZod.extend(StorageMetaZod3.shape);
+var TransactionBoundWitnessWithStorageMetaZod = TransactionBoundWitnessZod.safeExtend(StorageMetaZod2.shape);
 var isTransactionBoundWitnessWithStorageMeta = zodIsFactory5(TransactionBoundWitnessWithStorageMetaZod);
 var asTransactionBoundWitnessWithStorageMeta = zodAsFactory11(TransactionBoundWitnessWithStorageMetaZod, "asTransactionBoundWitnessWithStorageMeta");
 var toTransactionBoundWitnessWithStorageMeta = zodToFactory11(TransactionBoundWitnessWithStorageMetaZod, "toTransactionBoundWitnessWithStorageMeta");
-var UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod.extend(TransactionBoundWitnessFieldsZod.shape);
+var UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod2.safeExtend(TransactionBoundWitnessFieldsZod.shape);
 var isUnsignedTransactionBoundWitness = zodIsFactory5(UnsignedTransactionBoundWitnessZod);
 var asUnsignedTransactionBoundWitness = zodAsFactory11(UnsignedTransactionBoundWitnessZod, "asUnsignedTransactionBoundWitness");
 var toUnsignedTransactionBoundWitness = zodToFactory11(UnsignedTransactionBoundWitnessZod, "toUnsignedTransactionBoundWitness");
-var UnsignedTransactionBoundWitnessWithHashMetaZod = UnsignedTransactionBoundWitnessZod.extend(HashMetaZod2.shape);
+var UnsignedTransactionBoundWitnessWithHashMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(HashMetaZod2.shape);
 var isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory5(UnsignedTransactionBoundWitnessWithHashMetaZod);
 var asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory11(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
@@ -918,7 +891,7 @@ var toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory11(
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   "toUnsignedTransactionBoundWitnessWithHashMeta"
 );
-var UnsignedTransactionBoundWitnessWithStorageMetaZod = UnsignedTransactionBoundWitnessZod.extend(StorageMetaZod3.shape);
+var UnsignedTransactionBoundWitnessWithStorageMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(StorageMetaZod2.shape);
 var isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory5(UnsignedTransactionBoundWitnessWithStorageMetaZod);
 var asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory11(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
@@ -928,11 +901,11 @@ var toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory11(
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   "toUnsignedTransactionBoundWitnessWithStorageMeta"
 );
-var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.extend(TransactionBoundWitnessFieldsZod.shape);
+var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod2.safeExtend(TransactionBoundWitnessFieldsZod.shape);
 var isSignedTransactionBoundWitness = zodIsFactory5(SignedTransactionBoundWitnessZod);
 var asSignedTransactionBoundWitness = zodAsFactory11(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
 var toSignedTransactionBoundWitness = zodToFactory11(SignedTransactionBoundWitnessZod, "toSignedTransactionBoundWitness");
-var SignedTransactionBoundWitnessWithHashMetaZod = SignedTransactionBoundWitnessZod.extend(HashMetaZod2.shape);
+var SignedTransactionBoundWitnessWithHashMetaZod = SignedTransactionBoundWitnessZod.safeExtend(HashMetaZod2.shape);
 var isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory5(SignedTransactionBoundWitnessWithHashMetaZod);
 var asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory11(
   SignedTransactionBoundWitnessWithHashMetaZod,
@@ -942,7 +915,7 @@ var toSignedTransactionBoundWitnessWithHashMeta = zodToFactory11(
   SignedTransactionBoundWitnessWithHashMetaZod,
   "toSignedTransactionBoundWitnessWithHashMeta"
 );
-var SignedTransactionBoundWitnessWithStorageMetaZod = SignedTransactionBoundWitnessZod.extend(StorageMetaZod3.shape);
+var SignedTransactionBoundWitnessWithStorageMetaZod = SignedTransactionBoundWitnessZod.safeExtend(StorageMetaZod2.shape);
 var isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory5(SignedTransactionBoundWitnessWithStorageMetaZod);
 var asSignedTransactionBoundWitnessWithStorageMeta = zodAsFactory11(
   SignedTransactionBoundWitnessWithStorageMetaZod,
@@ -954,44 +927,44 @@ var toSignedTransactionBoundWitnessWithStorageMeta = zodToFactory11(
 );
 
 // src/zod/HydratedTransaction.ts
-var HydratedTransactionZod = z22.tuple([
+var HydratedTransactionZod = z21.tuple([
   TransactionBoundWitnessZod,
-  z22.array(PayloadZodLoose2)
+  z21.array(PayloadZodLoose2)
 ]);
 var isHydratedTransaction = zodIsFactory6(HydratedTransactionZod);
 var asHydratedTransaction = zodAsFactory12(HydratedTransactionZod, "asHydratedTransaction");
 var toHydratedTransaction = zodToFactory12(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z22.tuple([
+var HydratedTransactionWithHashMetaZod = z21.tuple([
   WithHashMetaZod2(TransactionBoundWitnessZod),
-  z22.array(WithHashMetaZod2(PayloadZodLoose2))
+  z21.array(WithHashMetaZod2(PayloadZodLoose2))
 ]);
 var isHydratedTransactionWithHashMeta = zodIsFactory6(HydratedTransactionWithHashMetaZod);
 var asHydratedTransactionWithHashMeta = zodAsFactory12(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
 var toHydratedTransactionWithHashMeta = zodToFactory12(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z22.tuple([
+var HydratedTransactionWithStorageMetaZod = z21.tuple([
   WithStorageMetaZod2(TransactionBoundWitnessZod),
-  z22.array(WithStorageMetaZod2(PayloadZodLoose2))
+  z21.array(WithStorageMetaZod2(PayloadZodLoose2))
 ]);
 var isHydratedTransactionWithStorageMeta = zodIsFactory6(HydratedTransactionWithStorageMetaZod);
 var asHydratedTransactionWithStorageMeta = zodAsFactory12(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
 var toHydratedTransactionWithStorageMeta = zodToFactory12(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z22.tuple([
+var UnsignedHydratedTransactionZod = z21.tuple([
   TransactionBoundWitnessZod,
-  z22.array(PayloadZodLoose2)
+  z21.array(PayloadZodLoose2)
 ]);
 var isUnsignedHydratedTransaction = zodIsFactory6(UnsignedHydratedTransactionZod);
 var asUnsignedHydratedTransaction = zodAsFactory12(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
 var toUnsignedHydratedTransaction = zodToFactory12(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z22.tuple([
+var UnsignedHydratedTransactionWithHashMetaZod = z21.tuple([
   WithHashMetaZod2(TransactionBoundWitnessZod),
-  z22.array(WithHashMetaZod2(PayloadZodLoose2))
+  z21.array(WithHashMetaZod2(PayloadZodLoose2))
 ]);
 var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory6(UnsignedHydratedTransactionWithHashMetaZod);
 var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory12(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
 var toUnsignedHydratedTransactionWithHashMeta = zodToFactory12(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z22.tuple([
+var UnsignedHydratedTransactionWithStorageMetaZod = z21.tuple([
   WithStorageMetaZod2(TransactionBoundWitnessZod),
-  z22.array(WithStorageMetaZod2(PayloadZodLoose2))
+  z21.array(WithStorageMetaZod2(PayloadZodLoose2))
 ]);
 var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory6(UnsignedHydratedTransactionWithStorageMetaZod);
 var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory12(
@@ -1002,23 +975,23 @@ var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory12(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z22.tuple([
+var SignedHydratedTransactionZod = z21.tuple([
   SignedTransactionBoundWitnessZod,
-  z22.array(PayloadZodLoose2)
+  z21.array(PayloadZodLoose2)
 ]);
 var isSignedHydratedTransaction = zodIsFactory6(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory12(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var toSignedHydratedTransaction = zodToFactory12(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z22.tuple([
+var SignedHydratedTransactionWithHashMetaZod = z21.tuple([
   WithHashMetaZod2(SignedTransactionBoundWitnessZod),
-  z22.array(WithHashMetaZod2(PayloadZodLoose2))
+  z21.array(WithHashMetaZod2(PayloadZodLoose2))
 ]);
 var isSignedHydratedTransactionWithHashMeta = zodIsFactory6(SignedHydratedTransactionWithHashMetaZod);
 var asSignedHydratedTransactionWithHashMeta = zodAsFactory12(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
 var toSignedHydratedTransactionWithHashMeta = zodToFactory12(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z22.tuple([
+var SignedHydratedTransactionWithStorageMetaZod = z21.tuple([
   WithStorageMetaZod2(SignedTransactionBoundWitnessZod),
-  z22.array(WithStorageMetaZod2(PayloadZodLoose2))
+  z21.array(WithStorageMetaZod2(PayloadZodLoose2))
 ]);
 var isSignedHydratedTransactionWithStorageMeta = zodIsFactory6(SignedHydratedTransactionWithStorageMetaZod);
 var asSignedHydratedTransactionWithStorageMeta = zodAsFactory12(
@@ -1029,91 +1002,77 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory12(
   SignedHydratedTransactionWithStorageMetaZod,
   "toSignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([
-  tx,
-  payloads
-]) => asSignedHydratedTransaction([
-  tx,
-  payloads.map((payload) => payload)
-]));
-var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(([
-  tx,
-  payloads
-]) => [
-  asSignedHydratedTransaction(tx),
-  payloads.map((p) => asAnyPayload(p))
-]);
 
 // src/zod/Permission.ts
-import { z as z23 } from "zod";
-var CaveatTypesZod = z23.enum(["chain", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z23.object({
+import { z as z22 } from "zod";
+var CaveatTypesZod = z22.enum(["chain", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z22.object({
   type: CaveatTypesZod,
-  value: z23.json()
+  value: z22.json()
 });
-var PermissionZod = z23.object({
-  parentCapability: z23.string(),
+var PermissionZod = z22.object({
+  parentCapability: z22.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z23.string()
+  invoker: z22.string()
 });
-var InvokerPermissionZod = PermissionZod.extend({ date: z23.number().optional() });
-var PermissionRequestZod = z23.record(z23.string(), z23.record(z23.string(), z23.any()));
-var RequestedPermissionZod = z23.object({
-  parentCapability: z23.string(),
-  date: z23.number().optional()
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z22.number().optional() });
+var PermissionRequestZod = z22.record(z22.string(), z22.record(z22.string(), z22.any()));
+var RequestedPermissionZod = z22.object({
+  parentCapability: z22.string(),
+  date: z22.number().optional()
 });
 
 // src/zod/RewardsRangeOptions.ts
-import { AddressZod as AddressZod4 } from "@xylabs/sdk-js";
-import { z as z24 } from "zod";
-var RewardsRangeOptionsZod = z24.object({
-  positions: z24.array(z24.number()).optional(),
+import { AddressZod as AddressZod3 } from "@xylabs/sdk-js";
+import { z as z23 } from "zod";
+var RewardsRangeOptionsZod = z23.object({
+  positions: z23.array(z23.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z24.array(StepIdentityZod).optional(),
-  stakers: z24.array(AddressZod4).optional()
+  steps: z23.array(StepIdentityZod).optional(),
+  stakers: z23.array(AddressZod3).optional()
 });
 
 // src/zod/Sequence.ts
 import { HexRegExMinMax, toHex } from "@xylabs/sdk-js";
 import { SequenceConstants } from "@xyo-network/payload-model";
-import * as z25 from "zod";
+import * as z24 from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z25.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z25.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z24.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z24.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z25.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z25.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z25.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z25.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+var QualifiedSequenceToStringZod = z24.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z24.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z24.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z24.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
 
 // src/zod/Stake.ts
-import { AddressZod as AddressZod5, HexZod as HexZod7 } from "@xylabs/sdk-js";
-import * as z26 from "zod";
-var StakeZod = z26.object({
+import { AddressZod as AddressZod4, HexZod as HexZod6 } from "@xylabs/sdk-js";
+import * as z25 from "zod";
+var StakeZod = z25.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z26.number(),
+  addBlock: z25.number(),
   // the unique id for the stake item
-  id: z26.number(),
+  id: z25.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z26.number(),
+  removeBlock: z25.number(),
   // the address that is being staked
-  staked: AddressZod5,
+  staked: AddressZod4,
   // the address that owns the stake
-  staker: AddressZod5,
+  staker: AddressZod4,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z26.number()
+  withdrawBlock: z25.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
   amount: AttoToJsonZod.parse(val.amount),
   id: val.id,
   removeBlock: val.removeBlock,
-  staked: AddressZod5.parse(val.staked),
-  staker: AddressZod5.parse(val.staker),
+  staked: AddressZod4.parse(val.staked),
+  staker: AddressZod4.parse(val.staker),
   withdrawBlock: val.withdrawBlock
 }));
-var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
+var JsonToStakeZod = StakeZod.extend({ amount: HexZod6 }).transform((val) => ({
   addBlock: val.addBlock,
   amount: JsonToAttoZod.parse(val.amount),
   id: val.id,
@@ -1124,24 +1083,24 @@ var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
 }));
 
 // src/zod/TimeDomain.ts
-import * as z27 from "zod";
-var TimeDomainZod = z27.union([
-  z27.literal("xl1"),
-  z27.literal("epoch"),
-  z27.literal("ethereum")
+import * as z26 from "zod";
+var TimeDomainZod = z26.union([
+  z26.literal("xl1"),
+  z26.literal("epoch"),
+  z26.literal("ethereum")
 ]);
 
 // src/zod/TransferPair.ts
-import { AddressZod as AddressZod6 } from "@xylabs/sdk-js";
-import z28 from "zod";
-var TransferPairZod = z28.tuple([
-  AddressZod6,
-  AddressZod6
+import { AddressZod as AddressZod5 } from "@xylabs/sdk-js";
+import z27 from "zod";
+var TransferPairZod = z27.tuple([
+  AddressZod5,
+  AddressZod5
 ]);
 
 // src/block/AllowedBlockPayload.ts
 var AllowedBlockPayloadSchemas = [
-  BoundWitnessSchema2,
+  BoundWitnessSchema,
   BridgeDestinationObservationSchema,
   BridgeIntentSchema,
   BridgeSourceObservationSchema,
@@ -1152,7 +1111,7 @@ var AllowedBlockPayloadSchemas = [
   TimeSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadSchemaZod = z29.enum(AllowedBlockPayloadSchemas);
+var AllowedBlockPayloadSchemaZod = z28.enum(AllowedBlockPayloadSchemas);
 var isAllowedBlockPayloadSchema = zodIsFactory7(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (value) => {
   return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isTimePayload(value) || isTransactionBoundWitness(value);
@@ -1331,10 +1290,6 @@ var isHydratedTransactionValidationError = (error) => {
 export {
   AllowedBlockPayloadSchemaZod,
   AllowedBlockPayloadSchemas,
-  AnyBoundWitnessZod,
-  AnySignedBoundWitnessWithStorageMetaZod,
-  AnySignedBoundWitnessZod,
-  AnyUnsignedBoundWitnessZod,
   ArrayBufferToJsonZod,
   AttoToJsonZod,
   AttoXL1,
@@ -1351,11 +1306,12 @@ export {
   BlockEndZod,
   BlockNumberSchema,
   BlockNumberZod,
+  BlockNumberishZod,
   BlockRangeZod,
+  BlockRangeishZod,
   BlockScriptsZod,
   BlockStartZod,
   BoundWitnessValidationError,
-  BoundWitnessZod,
   BridgeDestinationObservationFieldsZod,
   BridgeDestinationObservationSchema,
   BridgeDetailsDestinationFieldsZod,
@@ -1373,7 +1329,9 @@ export {
   ETH_BLOCK_NUMBER_ZERO,
   EpochTimeFieldsZod,
   EthBlockNumberZod,
+  EthBlockNumberishZod,
   EthBlockRangeZod,
+  EthBlockRangeishZod,
   EthereumTimeFieldsZod,
   FemtoXL1,
   FemtoXL1MaxValue,
@@ -1390,7 +1348,6 @@ export {
   InvokerPermissionZod,
   JsonToArrayBufferZod,
   JsonToAttoZod,
-  JsonToSignedHydratedTransactionZod,
   JsonToStakeZod,
   LocalSequenceFromStringZod,
   LocalSequenceToStringZod,
@@ -1401,12 +1358,6 @@ export {
   NanoXL1,
   NanoXL1MaxValue,
   NetworkStatusSchema,
-  NumberishBlockNumberZod,
-  NumberishBlockRangeZod,
-  NumberishEthBlockNumberZod,
-  NumberishEthBlockRangeZod,
-  NumberishXL1BlockNumberZod,
-  NumberishXL1BlockRangeZod,
   NumberishZod,
   PayloadZodOfSchema,
   PermissionRequestZod,
@@ -1424,20 +1375,16 @@ export {
   SignedBlockBoundWitnessWithHashMetaZod,
   SignedBlockBoundWitnessWithStorageMetaZod,
   SignedBlockBoundWitnessZod,
-  SignedBoundWitnessWithStorageMetaZod,
-  SignedBoundWitnessZod,
   SignedHydratedBlockToJsonZod,
   SignedHydratedBlockWithHashMetaZod,
   SignedHydratedBlockWithStorageMetaZod,
   SignedHydratedBlockZod,
-  SignedHydratedTransactionToJsonZod,
   SignedHydratedTransactionWithHashMetaZod,
   SignedHydratedTransactionWithStorageMetaZod,
   SignedHydratedTransactionZod,
   SignedTransactionBoundWitnessWithHashMetaZod,
   SignedTransactionBoundWitnessWithStorageMetaZod,
   SignedTransactionBoundWitnessZod,
-  SignedZod,
   StakeToJsonZod,
   StakeZod,
   StepCompleteSchema,
@@ -1467,20 +1414,19 @@ export {
   UnsignedBlockBoundWitnessWithHashMetaZod,
   UnsignedBlockBoundWitnessWithStorageMetaZod,
   UnsignedBlockBoundWitnessZod,
-  UnsignedBoundWitnessWithStorageMetaZod,
-  UnsignedBoundWitnessZod,
   UnsignedHydratedTransactionWithHashMetaZod,
   UnsignedHydratedTransactionWithStorageMetaZod,
   UnsignedHydratedTransactionZod,
   UnsignedTransactionBoundWitnessWithHashMetaZod,
   UnsignedTransactionBoundWitnessWithStorageMetaZod,
   UnsignedTransactionBoundWitnessZod,
-  UnsignedZod,
   ValidationError,
   XL1,
   XL1Amount,
   XL1BlockNumberZod,
+  XL1BlockNumberishZod,
   XL1BlockRangeZod,
+  XL1BlockRangeishZod,
   XL1MaxValue,
   XL1Places,
   XL1TimeFieldsZod,