@xyo-network/xl1-protocol 1.13.13 → 1.14.1

package/dist/neutral/index.mjs

@@ -284,11 +284,11 @@ var XL1Amount = class _XL1Amount {
 };
 
 // src/block/AllowedBlockPayload.ts
-import { zodIsFactory as zodIsFactory2 } from "@xylabs/zod";
-import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
-import { isHashMeta as isHashMeta3 } from "@xyo-network/payload-model";
+import { zodIsFactory as zodIsFactory6 } from "@xylabs/zod";
+import { BoundWitnessSchema as BoundWitnessSchema2 } from "@xyo-network/boundwitness-model";
+import { isHashMeta } from "@xyo-network/payload-model";
 import { isSchemaPayload, SchemaSchema } from "@xyo-network/schema-payload-plugin";
-import z15 from "zod";
+import z29 from "zod";
 
 // src/payload/elevatable/Bridge/BridgeDestinationObservation.ts
 import { HexZod as HexZod2 } from "@xylabs/hex";
@@ -615,188 +615,432 @@ var StepIdentitySchema = "network.xyo.chain.step.identity";
 var isStepIdentityPayload = isPayloadOfZodType4(StepIdentityZod, StepIdentitySchema);
 var asStepIdentityPayload = AsObjectFactory9.create(isStepIdentityPayload);
 
-// src/transaction/AnyHydratedTransaction.ts
-import { AsObjectFactory as AsObjectFactory12 } from "@xylabs/object";
+// src/zod/ArrayBuffer.ts
+import * as z15 from "zod";
+function base64Encode(u8) {
+  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
+    return Buffer.from(u8).toString("base64");
+  }
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < u8.length; i += chunk) {
+    binary += String.fromCharCode(...u8.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+function base64Decode(b64) {
+  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  const binary = atob(b64);
+  const u8 = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i);
+  return u8;
+}
+var ArrayBufferToJsonZod = z15.instanceof(ArrayBuffer).transform((x) => {
+  const u8 = new Uint8Array(x);
+  return base64Encode(u8);
+});
+var JsonToArrayBufferZod = z15.string().transform((x) => {
+  const u8 = base64Decode(x);
+  return u8.buffer;
+});
 
-// src/isHydratedBoundWitness.ts
-import { AsObjectFactory as AsObjectFactory10 } from "@xylabs/object";
-import { isBoundWitness } from "@xyo-network/boundwitness-model";
-import { isAnyPayload as isAnyPayload2, isStorageMeta as isStorageMeta2 } from "@xyo-network/payload-model";
-var isHydratedBoundWitness = (value) => {
-  return Array.isArray(value) && value.length === 2 && isBoundWitness(value[0]) && Array.isArray(value[1]) && !value[1].some((item) => !isAnyPayload2(item));
-};
-var isHydratedBoundWitnessWithStorageMeta = (value) => {
-  return isHydratedBoundWitness(value) && isStorageMeta2(value[0]) && !value[1].some((item) => !isStorageMeta2(item));
-};
-var asHydratedBoundWitness = AsObjectFactory10.create(
-  isHydratedBoundWitness
-);
-var asHydratedBoundWitnessWithStorageMeta = AsObjectFactory10.create(
-  isHydratedBoundWitnessWithStorageMeta
-);
+// src/zod/BlockBoundWitness.ts
+import { HashZod as HashZod3 } from "@xylabs/sdk-js";
+import * as z18 from "zod";
 
-// src/transaction/TransactionBoundWitness.ts
+// src/zod/BoundWitness.ts
 import {
-  isAddress
-} from "@xylabs/hex";
-import { AsObjectFactory as AsObjectFactory11 } from "@xylabs/object";
-import { isBoundWitness as isBoundWitness2 } from "@xyo-network/boundwitness-model";
-var isTransactionBoundWitness = (value) => {
-  const typedObj = value;
-  return isBoundWitness2(value) && isAddress(typedObj.chain) && typedObj.fees !== void 0 && typedObj.exp !== void 0 && typedObj.nbf !== void 0;
-};
-var asTransactionBoundWitness = AsObjectFactory11.create(isTransactionBoundWitness);
-
-// src/transaction/AnyHydratedTransaction.ts
-var isAnyHydratedTransaction = (value) => {
-  return isHydratedBoundWitness(value) && isTransactionBoundWitness(value[0]);
-};
-var asAnyHydratedTransaction = AsObjectFactory12.create(
-  isAnyHydratedTransaction
-);
-
-// src/transaction/HydratedTransaction.ts
-import { AsObjectFactory as AsObjectFactory13 } from "@xylabs/object";
-import { isSigned } from "@xyo-network/boundwitness-model";
+  AddressZod as AddressZod2,
+  HashZod as HashZod2,
+  HexZod as HexZod5
+} from "@xylabs/sdk-js";
+import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
 import {
-  isStorageMeta as isStorageMeta3
+  PayloadZod as PayloadZod2,
+  SchemaZod,
+  StorageMetaZod
 } from "@xyo-network/payload-model";
-var isHydratedTransaction = (value) => {
-  return isHydratedBoundWitness(value) && isTransactionBoundWitness(value[0]) && isSigned(value[0]) && isStorageMeta3(value[0]);
-};
-var asHydratedTransaction = AsObjectFactory13.create(
-  // eslint-disable-next-line sonarjs/deprecation
-  isHydratedTransaction
-);
+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());
+
+// 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));
+
+// src/zod/BlockBoundWitness.ts
+var BlockBoundWitnessFieldsZod = z18.object({
+  block: XL1BlockNumberZod,
+  chain: ChainZod,
+  previous: HashZod3.nullable(),
+  protocol: z18.number(),
+  step_hashes: z18.array(HashZod3).optional()
+});
+var BlockBoundWitnessMetaZod = z18.object({ $epoch: z18.number() });
+var BlockBoundWitnessZod = BoundWitnessZod.extend(BlockBoundWitnessFieldsZod.shape).extend(BlockBoundWitnessMetaZod.shape);
+var UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod.extend(BlockBoundWitnessFieldsZod.shape).extend(BlockBoundWitnessMetaZod.shape);
+var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.extend(BlockBoundWitnessFieldsZod.shape).extend(BlockBoundWitnessMetaZod.shape);
 
-// src/transaction/HydratedTransactionWithHashMeta.ts
-import { AsObjectFactory as AsObjectFactory14 } from "@xylabs/object";
+// src/zod/HydratedBlock.ts
+import {
+  zodAsFactory as zodAsFactory8,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory8
+} from "@xylabs/zod";
 import {
-  isStorageMeta as isStorageMeta4
+  PayloadZodLoose,
+  WithHashMetaZod,
+  WithStorageMetaZod
 } from "@xyo-network/payload-model";
-var isHydratedTransactionWithHashMeta = (value) => {
-  return isAnyHydratedTransaction(value) && isStorageMeta4(value[0]) && !value[1].some((v) => !isStorageMeta4(v));
-};
-var asHydratedTransactionWithHashMeta = AsObjectFactory14.create(
-  isHydratedTransactionWithHashMeta
-);
-
-// src/transaction/HydratedTransactionWithStorageMeta.ts
-import { AsObjectFactory as AsObjectFactory15 } from "@xylabs/object";
+import * as z19 from "zod";
+var HydratedBlockZod = z19.tuple([
+  BlockBoundWitnessZod,
+  z19.array(PayloadZodLoose)
+]);
+var isHydratedBlock = zodIsFactory2(HydratedBlockZod);
+var asHydratedBlock = zodAsFactory8(HydratedBlockZod, "asHydratedBlock");
+var toHydratedBlock = zodToFactory8(HydratedBlockZod, "toHydratedBlock");
+var HydratedBlockWithHashMetaZod = z19.tuple([
+  WithHashMetaZod(BlockBoundWitnessZod),
+  z19.array(WithHashMetaZod(PayloadZodLoose))
+]);
+var isHydratedBlockWithHashMeta = zodIsFactory2(HydratedBlockWithHashMetaZod);
+var asHydratedBlockWithHashMeta = zodAsFactory8(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
+var toHydratedBlockWithHashMeta = zodToFactory8(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
+var HydratedBlockWithStorageMetaZod = z19.tuple([
+  WithStorageMetaZod(BlockBoundWitnessZod),
+  z19.array(WithStorageMetaZod(PayloadZodLoose))
+]);
+var isHydratedBlockWithStorageMeta = zodIsFactory2(HydratedBlockWithStorageMetaZod);
+var asHydratedBlockWithStorageMeta = zodAsFactory8(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
+var toHydratedBlockWithStorageMeta = zodToFactory8(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
+var SignedHydratedBlockZod = z19.tuple([
+  SignedBlockBoundWitnessZod,
+  z19.array(PayloadZodLoose)
+]);
+var isSignedHydratedBlock = zodIsFactory2(SignedHydratedBlockZod);
+var asSignedHydratedBlock = zodAsFactory8(SignedHydratedBlockZod, "asSignedHydratedBlock");
+var toSignedHydratedBlock = zodToFactory8(SignedHydratedBlockZod, "toSignedHydratedBlock");
+var SignedHydratedBlockToJsonZod = z19.tuple([
+  SignedBlockBoundWitnessZod,
+  z19.array(PayloadZodLoose)
+]);
+var isSignedHydratedBlockToJson = zodIsFactory2(SignedHydratedBlockToJsonZod);
+var asSignedHydratedBlockToJson = zodAsFactory8(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
+var toSignedHydratedBlockToJson = zodToFactory8(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
+var SignedHydratedBlockWithHashMetaZod = z19.tuple([
+  WithHashMetaZod(SignedBlockBoundWitnessZod),
+  z19.array(WithHashMetaZod(PayloadZodLoose))
+]);
+var isSignedHydratedBlockWithHashMeta = zodIsFactory2(SignedHydratedBlockWithHashMetaZod);
+var asSignedHydratedBlockWithHashMeta = zodAsFactory8(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
+var toSignedHydratedBlockWithHashMeta = zodToFactory8(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
+var SignedHydratedBlockWithStorageMetaZod = z19.tuple([
+  WithStorageMetaZod(SignedBlockBoundWitnessZod),
+  z19.array(WithStorageMetaZod(PayloadZodLoose))
+]);
+
+// src/zod/HydratedTransaction.ts
 import {
-  isStorageMeta as isStorageMeta5
+  zodAsFactory as zodAsFactory11,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory11
+} from "@xylabs/zod";
+import {
+  asAnyPayload,
+  PayloadZodLoose as PayloadZodLoose2,
+  WithHashMetaZod as WithHashMetaZod2,
+  WithStorageMetaZod as WithStorageMetaZod2
 } from "@xyo-network/payload-model";
-var isHydratedTransactionWithStorageMeta = (value) => {
-  return isAnyHydratedTransaction(value) && isStorageMeta5(value[0]) && !value[1].some((v) => !isStorageMeta5(v));
-};
-var asHydratedTransactionWithStorageMeta = AsObjectFactory15.create(
-  isHydratedTransactionWithStorageMeta
-);
+import * as z22 from "zod";
 
-// src/transaction/SignedHydratedTransaction.ts
-import { AsObjectFactory as AsObjectFactory16 } from "@xylabs/object";
-import { isSigned as isSigned2 } from "@xyo-network/boundwitness-model";
-var isSignedHydratedTransaction = (value) => {
-  return isAnyHydratedTransaction(value) && isSigned2(value[0]);
-};
-var asSignedHydratedTransaction = AsObjectFactory16.create(
-  isSignedHydratedTransaction
-);
+// src/zod/TransactionBoundWitness.ts
+import { AddressZod as AddressZod3 } from "@xylabs/sdk-js";
+import {
+  zodAsFactory as zodAsFactory10,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory10
+} from "@xylabs/zod";
+import * as z21 from "zod";
 
-// src/transaction/SignedHydratedTransactionWithHashMeta.ts
-import { AsObjectFactory as AsObjectFactory17 } from "@xylabs/object";
-import { isStorageMeta as isStorageMeta6 } from "@xyo-network/payload-model";
-var isSignedHydratedTransactionWithHashMeta = (value) => {
-  return isSignedHydratedTransaction(value) && isStorageMeta6(value[0]) && !value[1].some((v) => !isStorageMeta6(v));
-};
-var asSignedHydratedTransactionWithHashMeta = AsObjectFactory17.create(
-  isSignedHydratedTransactionWithHashMeta
+// src/zod/TransactionFees.ts
+import {
+  BigIntToJsonZod,
+  HexZod as HexZod6,
+  JsonToBigIntZod
+} from "@xylabs/sdk-js";
+import {
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory9
+} from "@xylabs/zod";
+import * as z20 from "zod";
+var AttoZod = z20.bigint();
+var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
+var AttoToJsonZod = BigIntToJsonZod;
+var TransactionFeesHexZod = z20.object({
+  base: HexZod6,
+  gasLimit: HexZod6,
+  gasPrice: HexZod6,
+  priority: HexZod6
+});
+var isTransactionFeesHex = zodIsFactory3(TransactionFeesHexZod);
+var asTransactionFeesHex = zodAsFactory9(TransactionFeesHexZod, "asTransactionFeesHex");
+var toTransactionFeesHex = zodToFactory9(TransactionFeesHexZod, "toTransactionFeesHex");
+var TransactionFeesBigIntZod = z20.object({
+  base: AttoZod,
+  gasLimit: AttoZod,
+  gasPrice: AttoZod,
+  priority: AttoZod
+});
+var isTransactionFeesBigInt = zodIsFactory3(TransactionFeesBigIntZod);
+var asTransactionFeesBigInt = zodAsFactory9(TransactionFeesBigIntZod, "asTransactionFeesBigInt");
+var toTransactionFeesBigInt = zodToFactory9(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)
+}));
+
+// 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 TransactionBoundWitnessFields = z21.object({ chain: ChainZod, from: AddressZod3 });
+var TransactionBoundWitnessZod = BoundWitnessZod.extend(BlockDurationZod.shape).extend(TransactionFeesZod.shape).extend(TransactionBoundWitnessFields.shape).extend(BlockScriptsZod.shape);
+var isTransactionBoundWitness = zodIsFactory4(TransactionBoundWitnessZod);
+var asTransactionBoundWitness = zodAsFactory10(TransactionBoundWitnessZod, "asTransactionBoundWitness");
+var toTransactionBoundWitness = zodToFactory10(TransactionBoundWitnessZod, "toTransactionBoundWitness");
+var UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod.extend(BlockDurationZod.shape).extend(TransactionFeesZod.shape).extend(TransactionBoundWitnessFields.shape).extend(BlockScriptsZod.shape);
+var isUnsignedTransactionBoundWitness = zodIsFactory4(UnsignedTransactionBoundWitnessZod);
+var asUnsignedTransactionBoundWitness = zodAsFactory10(UnsignedTransactionBoundWitnessZod, "asUnsignedTransactionBoundWitness");
+var toUnsignedTransactionBoundWitness = zodToFactory10(UnsignedTransactionBoundWitnessZod, "toUnsignedTransactionBoundWitness");
+var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.extend(BlockDurationZod.shape).extend(TransactionFeesZod.shape).extend(TransactionBoundWitnessFields.shape).extend(BlockScriptsZod.shape);
+var isSignedTransactionBoundWitness = zodIsFactory4(SignedTransactionBoundWitnessZod);
+var asSignedTransactionBoundWitness = zodAsFactory10(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
+var toSignedTransactionBoundWitness = zodToFactory10(SignedTransactionBoundWitnessZod, "toSignedTransactionBoundWitness");
+
+// src/zod/HydratedTransaction.ts
+var HydratedTransactionZod = z22.tuple([
+  TransactionBoundWitnessZod,
+  z22.array(PayloadZodLoose2)
+]);
+var isHydratedTransaction = zodIsFactory5(HydratedTransactionZod);
+var asHydratedTransaction = zodAsFactory11(HydratedTransactionZod, "asHydratedTransaction");
+var toHydratedTransaction = zodToFactory11(HydratedTransactionZod, "toHydratedTransaction");
+var HydratedTransactionWithHashMetaZod = z22.tuple([
+  WithHashMetaZod2(TransactionBoundWitnessZod),
+  z22.array(WithHashMetaZod2(PayloadZodLoose2))
+]);
+var isHydratedTransactionWithHashMeta = zodIsFactory5(HydratedTransactionWithHashMetaZod);
+var asHydratedTransactionWithHashMeta = zodAsFactory11(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
+var toHydratedTransactionWithHashMeta = zodToFactory11(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
+var HydratedTransactionWithStorageMetaZod = z22.tuple([
+  WithStorageMetaZod2(TransactionBoundWitnessZod),
+  z22.array(WithStorageMetaZod2(PayloadZodLoose2))
+]);
+var isHydratedTransactionWithStorageMeta = zodIsFactory5(HydratedTransactionWithStorageMetaZod);
+var asHydratedTransactionWithStorageMeta = zodAsFactory11(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
+var toHydratedTransactionWithStorageMeta = zodToFactory11(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
+var UnsignedHydratedTransactionZod = z22.tuple([
+  TransactionBoundWitnessZod,
+  z22.array(PayloadZodLoose2)
+]);
+var isUnsignedHydratedTransaction = zodIsFactory5(UnsignedHydratedTransactionZod);
+var asUnsignedHydratedTransaction = zodAsFactory11(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
+var toUnsignedHydratedTransaction = zodToFactory11(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
+var UnsignedHydratedTransactionWithHashMetaZod = z22.tuple([
+  WithHashMetaZod2(TransactionBoundWitnessZod),
+  z22.array(WithHashMetaZod2(PayloadZodLoose2))
+]);
+var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory5(UnsignedHydratedTransactionWithHashMetaZod);
+var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory11(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
+var toUnsignedHydratedTransactionWithHashMeta = zodToFactory11(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
+var UnsignedHydratedTransactionWithStorageMetaZod = z22.tuple([
+  WithStorageMetaZod2(TransactionBoundWitnessZod),
+  z22.array(WithStorageMetaZod2(PayloadZodLoose2))
+]);
+var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory5(UnsignedHydratedTransactionWithStorageMetaZod);
+var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory11(
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  "asUnsignedHydratedTransactionWithStorageMeta"
 );
-
-// src/transaction/SignedHydratedTransactionWithStorageMeta.ts
-import { AsObjectFactory as AsObjectFactory18 } from "@xylabs/object";
-import { isStorageMeta as isStorageMeta7 } from "@xyo-network/payload-model";
-var isSignedHydratedTransactionWithStorageMeta = (value) => {
-  return isSignedHydratedTransaction(value) && isStorageMeta7(value[0]) && !value[1].some((v) => !isStorageMeta7(v));
-};
-var asSignedHydratedTransactionWithStorageMeta = AsObjectFactory18.create(
-  isSignedHydratedTransactionWithStorageMeta
+var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory11(
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  "toUnsignedHydratedTransactionWithStorageMeta"
 );
-
-// src/transaction/TransactionBoundWitnessDeprecated.ts
-import { AsObjectFactory as AsObjectFactory19 } from "@xylabs/object";
-import { isSigned as isSigned3 } from "@xyo-network/boundwitness-model";
-import { isHashMeta, isStorageMeta as isStorageMeta8 } from "@xyo-network/payload-model";
-var isSignedTransactionBoundWitness = (value) => {
-  return isTransactionBoundWitness(value) && isSigned3(value);
-};
-var isTransactionBoundWitnessWithStorageMeta = (value) => isTransactionBoundWitness(value) && isStorageMeta8(value);
-var isTransactionBoundWitnessWithHashMeta = (value) => isTransactionBoundWitness(value) && isHashMeta(value);
-var isSignedTransactionBoundWitnessWithStorageMeta = (value) => isSignedTransactionBoundWitness(value) && isStorageMeta8(value);
-var isSignedTransactionBoundWitnessWithHashMeta = (value) => isSignedTransactionBoundWitness(value) && isHashMeta(value);
-var asTransactionBoundWitnessWithStorageMeta = AsObjectFactory19.create(isTransactionBoundWitnessWithStorageMeta);
-var asTransactionBoundWitnessWithHashMeta = AsObjectFactory19.create(isTransactionBoundWitnessWithHashMeta);
-
-// src/transaction/TransactionFeesFields.ts
-import { isHex } from "@xylabs/hex";
-import { AsObjectFactory as AsObjectFactory20 } from "@xylabs/object";
-import { isObject } from "@xylabs/typeof";
-var isTransactionFeesBigInt = (value) => {
-  if (!isObject(value)) {
-    return false;
-  }
-  const {
-    base,
-    gasLimit,
-    gasPrice,
-    priority
-  } = value;
-  return isAttoXL1(base) && isAttoXL1(gasLimit) && isAttoXL1(gasPrice) && isAttoXL1(priority);
-};
-var asTransactionFeesBigInt = AsObjectFactory20.create(
-  isTransactionFeesBigInt
+var SignedHydratedTransactionZod = z22.tuple([
+  SignedTransactionBoundWitnessZod,
+  z22.array(PayloadZodLoose2)
+]);
+var isSignedHydratedTransaction = zodIsFactory5(SignedHydratedTransactionZod);
+var asSignedHydratedTransaction = zodAsFactory11(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
+var toSignedHydratedTransaction = zodToFactory11(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
+var SignedHydratedTransactionWithHashMetaZod = z22.tuple([
+  WithHashMetaZod2(SignedTransactionBoundWitnessZod),
+  z22.array(WithHashMetaZod2(PayloadZodLoose2))
+]);
+var isSignedHydratedTransactionWithHashMeta = zodIsFactory5(SignedHydratedTransactionWithHashMetaZod);
+var asSignedHydratedTransactionWithHashMeta = zodAsFactory11(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
+var toSignedHydratedTransactionWithHashMeta = zodToFactory11(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
+var SignedHydratedTransactionWithStorageMetaZod = z22.tuple([
+  WithStorageMetaZod2(SignedTransactionBoundWitnessZod),
+  z22.array(WithStorageMetaZod2(PayloadZodLoose2))
+]);
+var isSignedHydratedTransactionWithStorageMeta = zodIsFactory5(SignedHydratedTransactionWithStorageMetaZod);
+var asSignedHydratedTransactionWithStorageMeta = zodAsFactory11(
+  SignedHydratedTransactionWithStorageMetaZod,
+  "asSignedHydratedTransactionWithStorageMeta"
 );
-var isTransactionFeesHex = (value) => {
-  if (!isObject(value)) {
-    return false;
-  }
-  const {
-    base,
-    gasLimit,
-    gasPrice,
-    priority
-  } = value;
-  return isHex(base) && isHex(gasLimit) && isHex(gasPrice) && isHex(priority);
-};
-var asTransactionFeesHex = AsObjectFactory20.create(
-  isTransactionFeesHex
+var toSignedHydratedTransactionWithStorageMeta = zodToFactory11(
+  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({
+  type: CaveatTypesZod,
+  value: z23.json()
+});
+var PermissionZod = z23.object({
+  parentCapability: z23.string(),
+  caveats: CaveatsZod.array().optional(),
+  invoker: z23.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()
+});
 
-// src/transaction/UnsignedHydratedTransaction.ts
-import { AsObjectFactory as AsObjectFactory21 } from "@xylabs/object";
-import { isUnsigned } from "@xyo-network/boundwitness-model";
-var isUnsignedHydratedTransaction = (value) => {
-  return isAnyHydratedTransaction(value) && isUnsigned(value[0]);
-};
-var asUnsignedHydratedTransaction = AsObjectFactory21.create(
-  isUnsignedHydratedTransaction
-);
+// 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(),
+  range: BlockRangeZod.optional(),
+  steps: z24.array(StepIdentityZod).optional(),
+  stakers: z24.array(AddressZod4).optional()
+});
 
-// src/transaction/UnsignedHydratedTransactionWithHashMeta.ts
-import { AsObjectFactory as AsObjectFactory22 } from "@xylabs/object";
-import {
-  isHashMeta as isHashMeta2
-} from "@xyo-network/payload-model";
-var isUnsignedHydratedTransactionWithHashMeta = (value) => {
-  return isSignedHydratedTransaction(value) && isHashMeta2(value[0]) && !value[1].some((v) => !isHashMeta2(v));
-};
-var asUnsignedHydratedTransactionWithHashMeta = AsObjectFactory22.create(
-  isUnsignedHydratedTransactionWithHashMeta
-);
+// src/zod/Sequence.ts
+import { HexRegExMinMax, toHex } from "@xylabs/sdk-js";
+import { SequenceConstants } from "@xyo-network/payload-model";
+import * as z25 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 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]);
+
+// src/zod/Stake.ts
+import { AddressZod as AddressZod5, HexZod as HexZod7 } from "@xylabs/sdk-js";
+import * as z26 from "zod";
+var StakeZod = z26.object({
+  amount: AttoZod,
+  // the block number when the stake was added
+  addBlock: z26.number(),
+  // the unique id for the stake item
+  id: z26.number(),
+  // the block number when the stake was removed (set to 0 if not removed)
+  removeBlock: z26.number(),
+  // the address that is being staked
+  staked: AddressZod5,
+  // the address that owns the stake
+  staker: AddressZod5,
+  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
+  withdrawBlock: z26.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),
+  withdrawBlock: val.withdrawBlock
+}));
+var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
+  addBlock: val.addBlock,
+  amount: JsonToAttoZod.parse(val.amount),
+  id: val.id,
+  removeBlock: val.removeBlock,
+  staked: val.staked,
+  staker: val.staker,
+  withdrawBlock: val.withdrawBlock
+}));
+
+// src/zod/TimeDomain.ts
+import * as z27 from "zod";
+var TimeDomainZod = z27.union([
+  z27.literal("xl1"),
+  z27.literal("epoch"),
+  z27.literal("ethereum")
+]);
+
+// src/zod/TransferPair.ts
+import { AddressZod as AddressZod6 } from "@xylabs/sdk-js";
+import z28 from "zod";
+var TransferPairZod = z28.tuple([
+  AddressZod6,
+  AddressZod6
+]);
 
 // src/block/AllowedBlockPayload.ts
 var AllowedBlockPayloadSchemas = [
-  BoundWitnessSchema,
+  BoundWitnessSchema2,
   BridgeDestinationObservationSchema,
   BridgeIntentSchema,
   BridgeSourceObservationSchema,
@@ -807,54 +1051,14 @@ var AllowedBlockPayloadSchemas = [
   TimeSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadSchemaZod = z15.enum(AllowedBlockPayloadSchemas);
-var isAllowedBlockPayloadSchema = zodIsFactory2(AllowedBlockPayloadSchemaZod);
+var AllowedBlockPayloadSchemaZod = z29.enum(AllowedBlockPayloadSchemas);
+var isAllowedBlockPayloadSchema = zodIsFactory6(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (value) => {
   return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isTimePayload(value) || isTransactionBoundWitness(value);
 };
 var isAllowedBlockPayloadWithHashMeta = (value) => {
-  return isAllowedBlockPayload(value) && isHashMeta3(value);
-};
-
-// src/block/BlockBoundWitness.ts
-import { isHex as isHex2 } from "@xylabs/hex";
-import { AsObjectFactory as AsObjectFactory23 } from "@xylabs/object";
-import { isBoundWitness as isBoundWitness3, isSigned as isSigned4 } from "@xyo-network/boundwitness-model";
-import { isHashMeta as isHashMeta4, isStorageMeta as isStorageMeta9 } from "@xyo-network/payload-model";
-var isBlockBoundWitness = (value) => {
-  const typedObj = value;
-  return isBoundWitness3(value) && Number.isInteger(typedObj.block) && isHex2(typedObj.chain);
-};
-var isSignedBlockBoundWitness = (value) => {
-  return isBlockBoundWitness(value) && isSigned4(value);
-};
-var isBlockBoundWitnessWithStorageMeta = (value) => {
-  return isBlockBoundWitness(value) && isStorageMeta9(value);
-};
-var isSignedBlockBoundWitnessWithStorageMeta = (value) => {
-  return isBlockBoundWitnessWithStorageMeta(value) && isSigned4(value);
-};
-var isBlockBoundWitnessWithHashMeta = (value) => {
-  return isBlockBoundWitness(value) && isHashMeta4(value);
+  return isAllowedBlockPayload(value) && isHashMeta(value);
 };
-var isSignedBlockBoundWitnessWithHashMeta = (value) => {
-  return isBlockBoundWitnessWithHashMeta(value) && isSigned4(value);
-};
-var asBlockBoundWitness = AsObjectFactory23.create(isBlockBoundWitness);
-var asSignedBlockBoundWitness = AsObjectFactory23.create(isSignedBlockBoundWitness);
-var asBlockBoundWitnessWithStorageMeta = AsObjectFactory23.create(isBlockBoundWitnessWithStorageMeta);
-var asSignedBlockBoundWitnessWithStorageMeta = AsObjectFactory23.create(isSignedBlockBoundWitnessWithStorageMeta);
-var asBlockBoundWitnessWithHashMeta = AsObjectFactory23.create(isBlockBoundWitnessWithHashMeta);
-var asSignedBlockBoundWitnessWithHashMeta = AsObjectFactory23.create(isSignedBlockBoundWitnessWithHashMeta);
-
-// src/block/HydratedBlock.ts
-import { AsObjectFactory as AsObjectFactory24 } from "@xylabs/object";
-var isHydratedBlock = (value) => {
-  return isHydratedBoundWitness(value) && isBlockBoundWitnessWithStorageMeta(value[0]);
-};
-var asHydratedBlock = AsObjectFactory24.create(
-  isHydratedBlock
-);
 
 // src/constants/addresses.ts
 var XYO_ZERO_ADDRESS = "0000000000000000000000000000000000000000";
@@ -955,16 +1159,16 @@ var XL1_PROTOCOL_VERSION_STRING = `${XL1_PROTOCOL_VERSION_MAJOR}.${XL1_PROTOCOL_
 var XL1_PROTOCOL_VERSION = XL1_PROTOCOL_VERSION_MAJOR * 1e6 + XL1_PROTOCOL_VERSION_MINOR * 1e3 + XL1_PROTOCOL_VERSION_PATCH;
 
 // src/fields/BlockNumber.ts
-import { AsObjectFactory as AsObjectFactory25 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory10 } from "@xylabs/object";
 import {
   isPayloadOfSchemaType as isPayloadOfSchemaType6,
   isPayloadOfSchemaTypeWithSources
 } from "@xyo-network/payload-model";
 var BlockNumberSchema = "network.xyo.chain.block.number";
 var isBlockNumberPayload = isPayloadOfSchemaType6(BlockNumberSchema);
-var asBlockNumberPayload = AsObjectFactory25.create(isBlockNumberPayload);
+var asBlockNumberPayload = AsObjectFactory10.create(isBlockNumberPayload);
 var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
-var asBlockNumberPayloadWithSources = AsObjectFactory25.create(isBlockNumberPayloadWithSources);
+var asBlockNumberPayloadWithSources = AsObjectFactory10.create(isBlockNumberPayloadWithSources);
 
 // src/network/Status.ts
 import { isPayloadOfSchemaType as isPayloadOfSchemaType7 } from "@xyo-network/payload-model";
@@ -1026,14 +1230,29 @@ var isHydratedTransactionValidationError = (error) => {
 export {
   AllowedBlockPayloadSchemaZod,
   AllowedBlockPayloadSchemas,
+  AnyBoundWitnessZod,
+  AnySignedBoundWitnessWithStorageMetaZod,
+  AnySignedBoundWitnessZod,
+  AnyUnsignedBoundWitnessZod,
+  ArrayBufferToJsonZod,
+  AttoToJsonZod,
   AttoXL1,
   AttoXL1ConvertFactor,
   AttoXL1MaxValue,
+  AttoZod,
   BLOCK_NUMBER_ZERO,
+  BlockBoundWitnessFieldsZod,
+  BlockBoundWitnessMetaZod,
+  BlockBoundWitnessZod,
+  BlockDurationZod,
+  BlockEndZod,
   BlockNumberSchema,
   BlockNumberZod,
   BlockRangeZod,
+  BlockScriptsZod,
+  BlockStartZod,
   BoundWitnessValidationError,
+  BoundWitnessZod,
   BridgeDestinationObservationFieldsZod,
   BridgeDestinationObservationSchema,
   BridgeDetailsDestinationFieldsZod,
@@ -1043,7 +1262,10 @@ export {
   BridgeIntentSchema,
   BridgeSourceObservationFieldsZod,
   BridgeSourceObservationSchema,
+  CaveatTypesZod,
+  CaveatsZod,
   ChainStakeIntentSchema,
+  ChainZod,
   ELEVATE_OPCODE,
   ETH_BLOCK_NUMBER_ZERO,
   EpochTimeFieldsZod,
@@ -1053,9 +1275,22 @@ export {
   FemtoXL1,
   FemtoXL1MaxValue,
   HashSchema,
+  HydratedBlockWithHashMetaZod,
+  HydratedBlockWithStorageMetaZod,
+  HydratedBlockZod,
   HydratedBoundWitnessValidationError,
   HydratedTransactionValidationError,
+  HydratedTransactionWithHashMetaZod,
+  HydratedTransactionWithStorageMetaZod,
+  HydratedTransactionZod,
   InBlockPayloadValidationError,
+  InvokerPermissionZod,
+  JsonToArrayBufferZod,
+  JsonToAttoZod,
+  JsonToSignedHydratedTransactionZod,
+  JsonToStakeZod,
+  LocalSequenceFromStringZod,
+  LocalSequenceToStringZod,
   MicroXL1,
   MicroXL1MaxValue,
   MilliXL1,
@@ -1071,22 +1306,61 @@ export {
   NumberishXL1BlockRangeZod,
   NumberishZod,
   PayloadZodOfSchema,
+  PermissionRequestZod,
+  PermissionZod,
   PicoXL1,
   PicoXL1MaxValue,
+  QualifiedSequenceFromStringZod,
+  QualifiedSequenceToStringZod,
   RangeZod,
+  RequestedPermissionZod,
+  RewardsRangeOptionsZod,
+  SequenceFromStringZod,
+  SequenceToStringZod,
   ShiftedBigInt,
+  SignedBlockBoundWitnessZod,
+  SignedBoundWitnessWithStorageMetaZod,
+  SignedBoundWitnessZod,
+  SignedHydratedBlockToJsonZod,
+  SignedHydratedBlockWithHashMetaZod,
+  SignedHydratedBlockWithStorageMetaZod,
+  SignedHydratedBlockZod,
+  SignedHydratedTransactionToJsonZod,
+  SignedHydratedTransactionWithHashMetaZod,
+  SignedHydratedTransactionWithStorageMetaZod,
+  SignedHydratedTransactionZod,
+  SignedTransactionBoundWitnessZod,
+  SignedZod,
+  StakeToJsonZod,
+  StakeZod,
   StepCompleteSchema,
   StepIdentitySchema,
   StepIdentityZod,
   StepRewardFractions,
   StepSizes,
+  TimeDomainZod,
   TimeFieldsZod,
   TimePayloadZod,
   TimeSchema,
+  TransactionBoundWitnessZod,
+  TransactionFeesBigIntToJsonZod,
+  TransactionFeesBigIntZod,
+  TransactionFeesHexZod,
+  TransactionFeesJsonToBigIntZod,
+  TransactionFeesZod,
   TransactionGasCosts,
   TransferFieldsZod,
+  TransferPairZod,
   TransferSchema,
   TransferZod,
+  UnsignedBlockBoundWitnessZod,
+  UnsignedBoundWitnessWithStorageMetaZod,
+  UnsignedBoundWitnessZod,
+  UnsignedHydratedTransactionWithHashMetaZod,
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  UnsignedHydratedTransactionZod,
+  UnsignedTransactionBoundWitnessZod,
+  UnsignedZod,
   ValidationError,
   XL1,
   XL1Amount,
@@ -1110,11 +1384,7 @@ export {
   XYO_NETWORK_STAKING_ADDRESS,
   XYO_STEP_REWARD_ADDRESS,
   XYO_ZERO_ADDRESS,
-  asAnyHydratedTransaction,
   asAttoXL1,
-  asBlockBoundWitness,
-  asBlockBoundWitnessWithHashMeta,
-  asBlockBoundWitnessWithStorageMeta,
   asBlockNumber,
   asBlockNumberPayload,
   asBlockNumberPayloadWithSources,
@@ -1130,6 +1400,8 @@ export {
   asHashPayload,
   asHashPayloadWithStorageMeta,
   asHydratedBlock,
+  asHydratedBlockWithHashMeta,
+  asHydratedBlockWithStorageMeta,
   asHydratedTransaction,
   asHydratedTransactionWithHashMeta,
   asHydratedTransactionWithStorageMeta,
@@ -1138,25 +1410,26 @@ export {
   asNanoXL1,
   asPicoXL1,
   asRange,
-  asSignedBlockBoundWitness,
-  asSignedBlockBoundWitnessWithHashMeta,
-  asSignedBlockBoundWitnessWithStorageMeta,
+  asSignedHydratedBlock,
+  asSignedHydratedBlockToJson,
+  asSignedHydratedBlockWithHashMeta,
   asSignedHydratedTransaction,
   asSignedHydratedTransactionWithHashMeta,
   asSignedHydratedTransactionWithStorageMeta,
+  asSignedTransactionBoundWitness,
   asStepComplete,
   asStepIdentity,
   asStepIdentityPayload,
   asTimePayload,
   asTimePayloadWithStorageMeta,
   asTransactionBoundWitness,
-  asTransactionBoundWitnessWithHashMeta,
-  asTransactionBoundWitnessWithStorageMeta,
   asTransactionFeesBigInt,
   asTransactionFeesHex,
   asTransfer,
   asUnsignedHydratedTransaction,
   asUnsignedHydratedTransactionWithHashMeta,
+  asUnsignedHydratedTransactionWithStorageMeta,
+  asUnsignedTransactionBoundWitness,
   asValidStep,
   asXL1,
   asXL1BlockNumber,
@@ -1170,11 +1443,7 @@ export {
   isAllowedBlockPayload,
   isAllowedBlockPayloadSchema,
   isAllowedBlockPayloadWithHashMeta,
-  isAnyHydratedTransaction,
   isAttoXL1,
-  isBlockBoundWitness,
-  isBlockBoundWitnessWithHashMeta,
-  isBlockBoundWitnessWithStorageMeta,
   isBlockNumberPayload,
   isBlockNumberPayloadWithSources,
   isBoundWitnessValidationError,
@@ -1187,6 +1456,8 @@ export {
   isFemtoXL1,
   isHashPayload,
   isHydratedBlock,
+  isHydratedBlockWithHashMeta,
+  isHydratedBlockWithStorageMeta,
   isHydratedBoundWitnessValidationError,
   isHydratedTransaction,
   isHydratedTransactionValidationError,
@@ -1200,26 +1471,24 @@ export {
   isPicoXL1,
   isRange,
   isSafeEpoch,
-  isSignedBlockBoundWitness,
-  isSignedBlockBoundWitnessWithHashMeta,
-  isSignedBlockBoundWitnessWithStorageMeta,
+  isSignedHydratedBlock,
+  isSignedHydratedBlockToJson,
+  isSignedHydratedBlockWithHashMeta,
   isSignedHydratedTransaction,
   isSignedHydratedTransactionWithHashMeta,
   isSignedHydratedTransactionWithStorageMeta,
   isSignedTransactionBoundWitness,
-  isSignedTransactionBoundWitnessWithHashMeta,
-  isSignedTransactionBoundWitnessWithStorageMeta,
   isStepComplete,
   isStepIdentityPayload,
   isTimePayload,
   isTransactionBoundWitness,
-  isTransactionBoundWitnessWithHashMeta,
-  isTransactionBoundWitnessWithStorageMeta,
   isTransactionFeesBigInt,
   isTransactionFeesHex,
   isTransfer,
   isUnsignedHydratedTransaction,
   isUnsignedHydratedTransactionWithHashMeta,
+  isUnsignedHydratedTransactionWithStorageMeta,
+  isUnsignedTransactionBoundWitness,
   isValidStep,
   isValidationError,
   isXL1,
@@ -1235,11 +1504,31 @@ export {
   toEthBlockNumberKey,
   toEthBlockRange,
   toFemtoXL1,
+  toHydratedBlock,
+  toHydratedBlockWithHashMeta,
+  toHydratedBlockWithStorageMeta,
+  toHydratedTransaction,
+  toHydratedTransactionWithHashMeta,
+  toHydratedTransactionWithStorageMeta,
   toMicroXL1,
   toMilliXL1,
   toNanoXL1,
   toPicoXL1,
   toRange,
+  toSignedHydratedBlock,
+  toSignedHydratedBlockToJson,
+  toSignedHydratedBlockWithHashMeta,
+  toSignedHydratedTransaction,
+  toSignedHydratedTransactionWithHashMeta,
+  toSignedHydratedTransactionWithStorageMeta,
+  toSignedTransactionBoundWitness,
+  toTransactionBoundWitness,
+  toTransactionFeesBigInt,
+  toTransactionFeesHex,
+  toUnsignedHydratedTransaction,
+  toUnsignedHydratedTransactionWithHashMeta,
+  toUnsignedHydratedTransactionWithStorageMeta,
+  toUnsignedTransactionBoundWitness,
   toXL1,
   toXL1BlockNumber,
   toXL1BlockNumberKey,