@xyo-network/xl1-protocol-model 1.26.1

package/dist/neutral/index.mjs

@@ -0,0 +1,1699 @@
+// src/block/AllowedBlockPayload.ts
+import { zodIsFactory as zodIsFactory3 } from "@xylabs/sdk-js";
+import {
+  BoundWitnessSchema,
+  isHashMeta,
+  isSchemaPayload,
+  SchemaSchema
+} from "@xyo-network/sdk-js";
+import { z as z14 } 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";
+
+// src/payload/elevatable/Bridge/BridgeDetails.ts
+import { HexZod } from "@xylabs/sdk-js";
+import { z } from "zod";
+var BridgeDetailsDestinationFieldsZod = z.object({
+  /**
+   * Destination network
+   */
+  dest: HexZod.describe("The destination network identifier"),
+  /**
+   * Destination address (EOA or contract)
+   */
+  destAddress: HexZod.describe("The destination address (EOA or contract)"),
+  /**
+   * Token amount to bridge to destination
+   */
+  destAmount: HexZod.describe("The token amount to bridge to destination"),
+  /**
+   * Token being bridged to
+   */
+  destToken: HexZod.describe("The token being bridged to")
+});
+var BridgeDetailsSourceFieldsZod = z.object({
+  /**
+   * Source network
+   */
+  src: HexZod.describe("The source network identifier"),
+  /**
+   * Source address (EOA or contract)
+   */
+  srcAddress: HexZod.describe("The source address (EOA or contract)"),
+  /**
+   * Token amount to bridge from source
+   */
+  srcAmount: HexZod.describe("The token amount to bridge from source"),
+  /**
+   * Token being bridged from
+   */
+  srcToken: HexZod.describe("The token being bridged from")
+});
+var BridgeDetailsFieldsZod = BridgeDetailsSourceFieldsZod.extend(
+  BridgeDetailsDestinationFieldsZod.shape
+);
+
+// src/payload/elevatable/Bridge/BridgeDestinationObservation.ts
+var BridgeDestinationObservationSchema = asSchema("network.xyo.chain.bridge.observation.destination", true);
+var BridgeDestinationObservationFieldsZod = BridgeDetailsFieldsZod.extend({
+  /**
+   * Destination chain confirmation
+   */
+  destConfirmation: HexZod2.optional().describe("Destination chain confirmation")
+});
+var isBridgeDestinationObservation = isPayloadOfZodType(
+  BridgeDestinationObservationFieldsZod,
+  BridgeDestinationObservationSchema
+);
+var asBridgeDestinationObservation = AsObjectFactory.create(isBridgeDestinationObservation);
+
+// 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";
+var BridgeIntentSchema = asSchema2("network.xyo.chain.bridge.intent", true);
+var BridgeIntentFieldsZod = BridgeDetailsFieldsZod.extend({
+  /**
+   * Unique identifier for replay protection
+   */
+  nonce: z2.string().describe("Unique identifier for replay protection")
+});
+var isBridgeIntent = isPayloadOfZodType2(
+  BridgeIntentFieldsZod,
+  BridgeIntentSchema
+);
+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";
+var BridgeSourceObservationSchema = asSchema3("network.xyo.chain.bridge.observation.source", true);
+var BridgeSourceObservationFieldsZod = BridgeDetailsFieldsZod.extend({
+  /**
+   * Source chain confirmation
+   */
+  srcConfirmation: HexZod3.optional().describe("Source chain confirmation")
+});
+var isBridgeSourceObservation = isPayloadOfZodType3(
+  BridgeSourceObservationFieldsZod,
+  BridgeSourceObservationSchema
+);
+var asBridgeSourceObservation = AsObjectFactory3.create(isBridgeSourceObservation);
+
+// src/payload/elevatable/ChainStakeIntent.ts
+import { AsObjectFactory as AsObjectFactory4 } from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema4,
+  isPayloadOfSchemaType,
+  isStorageMeta
+} from "@xyo-network/sdk-js";
+var ChainStakeIntentSchema = asSchema4("network.xyo.chain.stake.intent", true);
+var isChainStakeIntent = (x) => {
+  return isPayloadOfSchemaType(ChainStakeIntentSchema)(x) && asNonNegativeInteger(x.nbf) !== void 0 && asNonNegativeInteger(x.exp) !== void 0;
+};
+var asChainStakeIntent = AsObjectFactory4.create(isChainStakeIntent);
+var isChainStakeIntentWithStorageMeta = (x) => {
+  return isChainStakeIntent(x) && isStorageMeta(x);
+};
+var asNonNegativeInteger = (num) => {
+  return Number.isInteger(num) && num >= 0 ? num : void 0;
+};
+
+// src/payload/elevatable/Executable.ts
+import { isAnyPayload } from "@xyo-network/sdk-js";
+var hasFrom = (value) => {
+  return value.from !== void 0;
+};
+var isExecutable = (value) => {
+  return isAnyPayload(value) && Array.isArray(value.script);
+};
+var asExecutable = (value) => {
+  return isExecutable(value) ? value : void 0;
+};
+
+// src/payload/elevatable/Hash.ts
+import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
+import { asSchema as asSchema5, isPayloadOfSchemaType as isPayloadOfSchemaType2 } from "@xyo-network/sdk-js";
+var HashSchema = asSchema5("network.xyo.hash", true);
+var isHashPayload = isPayloadOfSchemaType2(HashSchema);
+var asHashPayload = AsObjectFactory5.create(isHashPayload);
+var asHashPayloadWithStorageMeta = AsObjectFactory5.create(isHashPayload);
+
+// src/payload/elevatable/StepComplete.ts
+import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/sdk-js";
+import { asSchema as asSchema6, isPayloadOfSchemaType as isPayloadOfSchemaType3 } from "@xyo-network/sdk-js";
+var StepCompleteSchema = asSchema6("network.xyo.chain.step.complete", true);
+var isStepComplete = isPayloadOfSchemaType3(StepCompleteSchema);
+var asStepComplete = AsObjectFactory6.create(isStepComplete);
+
+// src/payload/elevatable/Time.ts
+import { AsObjectFactory as AsObjectFactory7, HashZod } from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema7,
+  isPayloadOfSchemaType as isPayloadOfSchemaType4,
+  PayloadZodOfSchema
+} from "@xyo-network/sdk-js";
+import { z as z3 } from "zod";
+var TimeSchema = asSchema7("network.xyo.time", true);
+var XL1TimeFieldsZod = z3.object({
+  // block number
+  xl1: z3.number().optional(),
+  // block hash
+  xl1Hash: HashZod.optional()
+});
+var EthereumTimeFieldsZod = z3.object({
+  // block number
+  ethereum: z3.number().optional(),
+  // block hash
+  ethereumHash: HashZod.optional()
+});
+var EpochTimeFieldsZod = z3.object({
+  // in milliseconds
+  epoch: z3.number()
+});
+var TimeFieldsZod = XL1TimeFieldsZod.extend(XL1TimeFieldsZod.shape).extend(EthereumTimeFieldsZod.shape).extend(EpochTimeFieldsZod.shape);
+var TimePayloadZod = PayloadZodOfSchema(TimeSchema).extend(TimeFieldsZod.shape);
+var isSafeEpoch = (value) => {
+  return typeof value === "number" && value < 2 * Date.now();
+};
+var isTimePayload = (value) => {
+  return isPayloadOfSchemaType4(TimeSchema)(value) && isSafeEpoch(value.epoch);
+};
+var asTimePayload = AsObjectFactory7.create(isTimePayload);
+var asTimePayloadWithStorageMeta = AsObjectFactory7.create(isTimePayload);
+
+// src/payload/StepIdentityPayload.ts
+import { AsObjectFactory as AsObjectFactory8 } from "@xylabs/sdk-js";
+import { asSchema as asSchema8, isPayloadOfZodType as isPayloadOfZodType4 } from "@xyo-network/sdk-js";
+
+// src/Step/StepIdentity.ts
+import { isUndefined } from "@xylabs/sdk-js";
+import { z as z8 } from "zod";
+
+// src/BlockNumber/BlockNumber.ts
+import { zodAsFactory, zodToFactory } from "@xylabs/sdk-js";
+import { z as z5 } 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());
+
+// src/BlockNumber/BlockNumber.ts
+var BlockNumberZod = z5.number().transform((v) => v);
+var BlockNumberishZod = NumberishZod.transform((v) => v);
+var asBlockNumber = zodAsFactory(BlockNumberZod, "asBlockNumber");
+var toBlockNumber = zodToFactory(BlockNumberishZod, "toBlockNumber");
+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);
+var EthBlockNumberishZod = BlockNumberishZod.transform((v) => v);
+var asEthBlockNumber = zodAsFactory2(EthBlockNumberZod, "asEthBlockNumber");
+var toEthBlockNumber = zodToFactory2(EthBlockNumberishZod, "toEthBlockNumber");
+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);
+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({
+  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")
+});
+function tryParseInt(value) {
+  if (value === "") return void 0;
+  const num = Number(value);
+  return Number.isInteger(num) ? num : void 0;
+}
+var asStepIdentity = (stepIdentityString) => {
+  try {
+    const [blockNumberString, stepString] = stepIdentityString.split("|");
+    if (isUndefined(blockNumberString) || isUndefined(stepString)) {
+      return void 0;
+    }
+    const step = tryParseInt(stepString);
+    const block = toXL1BlockNumber(blockNumberString);
+    if (isUndefined(block) || isUndefined(step)) {
+      return void 0;
+    }
+    return { block, step };
+  } catch {
+    return void 0;
+  }
+};
+
+// src/Step/StepSizes.ts
+import { AsTypeFactory } from "@xylabs/sdk-js";
+var StepSizes = [
+  asXL1BlockNumber(7, true),
+  asXL1BlockNumber(31, true),
+  asXL1BlockNumber(211, true),
+  asXL1BlockNumber(2311, true),
+  asXL1BlockNumber(30031, true),
+  asXL1BlockNumber(510511, true),
+  asXL1BlockNumber(9699691, true),
+  asXL1BlockNumber(223092871, true),
+  asXL1BlockNumber(6469693231, true)
+];
+function isValidStep(step) {
+  if (typeof step === "number" && Number.isInteger(step)) {
+    return step >= 0 && step < StepSizes.length;
+  }
+  return false;
+}
+var asValidStep = AsTypeFactory.create(isValidStep);
+function stepSize(step) {
+  const validatedStep = asValidStep(step, () => `Invalid step (${step}), must be an integer between 0 and ${StepSizes.length - 1}`, { required: true });
+  return StepSizes[validatedStep];
+}
+var StepRewardFractions = [
+  [0n, 1n],
+  // 0%
+  [0n, 1n],
+  // 0%
+  [0n, 1n],
+  // 0%
+  [1n, 10000n],
+  // 0.01%
+  [2n, 1000n],
+  // 0.2%
+  [3n, 100n],
+  // 3%
+  [45n, 100n]
+  // 45%
+];
+
+// src/payload/StepIdentityPayload.ts
+var StepIdentitySchema = asSchema8("network.xyo.chain.step.identity", true);
+var isStepIdentityPayload = isPayloadOfZodType4(StepIdentityZod, StepIdentitySchema);
+var asStepIdentityPayload = AsObjectFactory8.create(isStepIdentityPayload);
+
+// src/transaction/TransactionBoundWitness.ts
+import {
+  AddressZod,
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory5
+} from "@xylabs/sdk-js";
+import {
+  BoundWitnessZod,
+  HashMetaZod,
+  SignedBoundWitnessZod,
+  StorageMetaZod,
+  UnsignedBoundWitnessZod,
+  WithHashMetaZod,
+  WithStorageMetaZod
+} from "@xyo-network/sdk-js";
+import { z as z12 } from "zod";
+
+// 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));
+
+// src/transaction/TransactionFees.ts
+import {
+  BigIntToJsonZod,
+  HexZod as HexZod4,
+  JsonToBigIntZod,
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory,
+  zodToFactory as zodToFactory4
+} from "@xylabs/sdk-js";
+import { z as z11 } from "zod";
+
+// src/xl1/isXL1Factory.ts
+import { z as z10 } from "zod";
+
+// src/xl1/xl1MaxValue.ts
+var xl1MaxValue = (places) => 10n ** (32n - places) - 1n;
+
+// src/xl1/isXL1Factory.ts
+var isXL1Factory = (places) => (val) => {
+  if (typeof val !== "bigint") return false;
+  return val >= 0n && val <= xl1MaxValue(places);
+};
+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(
+    (x) => {
+      const result = is(x);
+      return result;
+    },
+    { message }
+  );
+};
+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(
+    (x) => {
+      const result = is(x);
+      return result;
+    },
+    { message }
+  );
+};
+var asXL1Factory = (places) => {
+  const zod = XL1ZodFactory(places, "local");
+  return (val) => {
+    const result = zod.safeParse(val);
+    if (result.success) {
+      return result.data;
+    }
+    throw result.error;
+  };
+};
+var toXL1Factory = (places) => {
+  const zod = XL1TransformZodFactory(places, "local");
+  return (val) => {
+    const result = zod.safeParse(val);
+    return result.success ? result.data : void 0;
+  };
+};
+
+// src/xl1/XL1Units.ts
+var XL1Places = {
+  xl1: 18n,
+  milli: 15n,
+  micro: 12n,
+  nano: 9n,
+  pico: 6n,
+  femto: 3n,
+  atto: 0n
+};
+var AttoXL1ConvertFactor = {
+  xl1: 10n ** XL1Places.xl1,
+  milli: 10n ** XL1Places.milli,
+  micro: 10n ** XL1Places.micro,
+  nano: 10n ** XL1Places.nano,
+  pico: 10n ** XL1Places.pico,
+  femto: 10n ** XL1Places.femto,
+  atto: 10n ** XL1Places.atto
+};
+
+// src/xl1/AttoXL1.ts
+var AttoXL1MaxValue = xl1MaxValue(XL1Places.atto);
+var isAttoXL1 = isXL1Factory(XL1Places.atto);
+var asAttoXL1 = asXL1Factory(XL1Places.atto);
+var toAttoXL1 = toXL1Factory(XL1Places.atto);
+var AttoXL1 = asAttoXL1;
+
+// src/xl1/FemtoXL1.ts
+var FemtoXL1MaxValue = xl1MaxValue(XL1Places.femto);
+var isFemtoXL1 = isXL1Factory(XL1Places.femto);
+var asFemtoXL1 = asXL1Factory(XL1Places.femto);
+var toFemtoXL1 = toXL1Factory(XL1Places.femto);
+var FemtoXL1 = asFemtoXL1;
+
+// src/xl1/MicroXL1.ts
+var MicroXL1MaxValue = xl1MaxValue(XL1Places.micro);
+var isMicroXL1 = isXL1Factory(XL1Places.micro);
+var asMicroXL1 = asXL1Factory(XL1Places.micro);
+var toMicroXL1 = toXL1Factory(XL1Places.micro);
+var MicroXL1 = asMicroXL1;
+
+// src/xl1/MilliXL1.ts
+var MilliXL1MaxValue = xl1MaxValue(XL1Places.milli);
+var isMilliXL1 = isXL1Factory(XL1Places.milli);
+var asMilliXL1 = asXL1Factory(XL1Places.milli);
+var toMilliXL1 = toXL1Factory(XL1Places.milli);
+var MilliXL1 = asMilliXL1;
+
+// src/xl1/NanoXL1.ts
+var NanoXL1MaxValue = xl1MaxValue(XL1Places.nano);
+var isNanoXL1 = isXL1Factory(XL1Places.nano);
+var asNanoXL1 = asXL1Factory(XL1Places.nano);
+var toNanoXL1 = toXL1Factory(XL1Places.nano);
+var NanoXL1 = asNanoXL1;
+
+// src/xl1/PicoXL1.ts
+var PicoXL1MaxValue = xl1MaxValue(XL1Places.pico);
+var isPicoXL1 = isXL1Factory(XL1Places.pico);
+var asPicoXL1 = asXL1Factory(XL1Places.pico);
+var toPicoXL1 = toXL1Factory(XL1Places.pico);
+var PicoXL1 = asPicoXL1;
+
+// src/xl1/XL1.ts
+var XL1MaxValue = xl1MaxValue(XL1Places.xl1);
+var isXL1 = isXL1Factory(XL1Places.xl1);
+var asXL1 = asXL1Factory(XL1Places.xl1);
+var toXL1 = toXL1Factory(XL1Places.xl1);
+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({
+  base: HexZod4,
+  gasLimit: HexZod4,
+  gasPrice: HexZod4,
+  priority: HexZod4
+});
+var isTransactionFeesHex = zodIsFactory(TransactionFeesHexZod);
+var asTransactionFeesHex = zodAsFactory4(TransactionFeesHexZod, "asTransactionFeesHex");
+var toTransactionFeesHex = zodToFactory4(TransactionFeesHexZod, "toTransactionFeesHex");
+var TransactionFeesBigIntZod = z11.object({
+  base: AttoZod,
+  gasLimit: AttoZod,
+  gasPrice: AttoZod,
+  priority: AttoZod
+});
+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)
+}));
+
+// 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 isTransactionBoundWitness = zodIsFactory2(TransactionBoundWitnessZod);
+var asTransactionBoundWitness = zodAsFactory5(TransactionBoundWitnessZod, "asTransactionBoundWitness");
+var toTransactionBoundWitness = zodToFactory5(TransactionBoundWitnessZod, "toTransactionBoundWitness");
+var TransactionBoundWitnessWithHashMetaZod = TransactionBoundWitnessZod.safeExtend(HashMetaZod.shape);
+var isTransactionBoundWitnessWithHashMeta = zodIsFactory2(TransactionBoundWitnessWithHashMetaZod);
+var asTransactionBoundWitnessWithHashMeta = zodAsFactory5(TransactionBoundWitnessWithHashMetaZod, "asTransactionBoundWitnessWithHashMeta");
+var toTransactionBoundWitnessWithHashMeta = zodToFactory5(TransactionBoundWitnessWithHashMetaZod, "toTransactionBoundWitnessWithHashMeta");
+var TransactionBoundWitnessWithStorageMetaZod = TransactionBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var isTransactionBoundWitnessWithStorageMeta = zodIsFactory2(TransactionBoundWitnessWithStorageMetaZod);
+var asTransactionBoundWitnessWithStorageMeta = zodAsFactory5(TransactionBoundWitnessWithStorageMetaZod, "asTransactionBoundWitnessWithStorageMeta");
+var toTransactionBoundWitnessWithStorageMeta = zodToFactory5(TransactionBoundWitnessWithStorageMetaZod, "toTransactionBoundWitnessWithStorageMeta");
+var UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
+var isUnsignedTransactionBoundWitness = zodIsFactory2(UnsignedTransactionBoundWitnessZod);
+var asUnsignedTransactionBoundWitness = zodAsFactory5(UnsignedTransactionBoundWitnessZod, "asUnsignedTransactionBoundWitness");
+var toUnsignedTransactionBoundWitness = zodToFactory5(UnsignedTransactionBoundWitnessZod, "toUnsignedTransactionBoundWitness");
+var UnsignedTransactionBoundWitnessWithHashMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(HashMetaZod.shape);
+var isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory2(UnsignedTransactionBoundWitnessWithHashMetaZod);
+var asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory5(
+  UnsignedTransactionBoundWitnessWithHashMetaZod,
+  "asUnsignedTransactionBoundWitnessWithHashMeta"
+);
+var toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory5(
+  UnsignedTransactionBoundWitnessWithHashMetaZod,
+  "toUnsignedTransactionBoundWitnessWithHashMeta"
+);
+var UnsignedTransactionBoundWitnessWithStorageMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory2(UnsignedTransactionBoundWitnessWithStorageMetaZod);
+var asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory5(
+  UnsignedTransactionBoundWitnessWithStorageMetaZod,
+  "asUnsignedTransactionBoundWitnessWithStorageMeta"
+);
+var toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory5(
+  UnsignedTransactionBoundWitnessWithStorageMetaZod,
+  "toUnsignedTransactionBoundWitnessWithStorageMeta"
+);
+var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
+var isSignedTransactionBoundWitness = zodIsFactory2(SignedTransactionBoundWitnessZod);
+var asSignedTransactionBoundWitness = zodAsFactory5(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
+var toSignedTransactionBoundWitness = zodToFactory5(SignedTransactionBoundWitnessZod, "toSignedTransactionBoundWitness");
+var SignedTransactionBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedTransactionBoundWitnessZod);
+var isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory2(SignedTransactionBoundWitnessWithHashMetaZod);
+var asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory5(
+  SignedTransactionBoundWitnessWithHashMetaZod,
+  "asSignedTransactionBoundWitnessWithHashMeta"
+);
+var toSignedTransactionBoundWitnessWithHashMeta = zodToFactory5(
+  SignedTransactionBoundWitnessWithHashMetaZod,
+  "toSignedTransactionBoundWitnessWithHashMeta"
+);
+var SignedTransactionBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedTransactionBoundWitnessZod);
+var isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory2(SignedTransactionBoundWitnessWithStorageMetaZod);
+var asSignedTransactionBoundWitnessWithStorageMeta = zodAsFactory5(
+  SignedTransactionBoundWitnessWithStorageMetaZod,
+  "asSignedTransactionBoundWitnessWithStorageMeta"
+);
+var toSignedTransactionBoundWitnessWithStorageMeta = zodToFactory5(
+  SignedTransactionBoundWitnessWithStorageMetaZod,
+  "toSignedTransactionBoundWitnessWithStorageMeta"
+);
+
+// src/transaction/TransactionGasCosts.ts
+var TransactionGasCosts = {
+  /**
+   * The cost of storing each character that is added to the chain
+   * This includes the transaction JSON and all the elevated payloads' JSON
+  */
+  characterStorage: 10n,
+  /** The cost of static validating every payload that will be included in the chain */
+  payloadValidation: 1000n,
+  /** The cost of validating each signature that will be included in the chain */
+  signatureValidation: 1000n,
+  /** The cost of validating each hash that will be included in the chain */
+  hashValidation: 100n,
+  /** The cost of validating a balance state, triggered by a Transfer payload or gas collection */
+  balanceValidation: 100n
+};
+
+// src/TransferPayload.ts
+import {
+  AddressZod as AddressZod2,
+  AsObjectFactory as AsObjectFactory9,
+  HexZod as HexZod5,
+  JsonObjectZod
+} from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema9,
+  isPayloadOfSchemaType as isPayloadOfSchemaType5,
+  PayloadZodOfSchema as PayloadZodOfSchema2
+} from "@xyo-network/sdk-js";
+import { z as z13 } from "zod";
+var TransferSchema = asSchema9("network.xyo.transfer", true);
+var TransferFieldsZod = z13.object({
+  // Removed as only transaction have opCodes
+  // $opCodes: z.array(z.string()).optional(),
+  context: JsonObjectZod.optional(),
+  epoch: z13.number(),
+  from: AddressZod2,
+  transfers: z13.record(AddressZod2, HexZod5)
+});
+var TransferZod = PayloadZodOfSchema2(TransferSchema).extend(TransferFieldsZod.shape);
+var isTransfer = isPayloadOfSchemaType5(TransferSchema);
+var asTransfer = AsObjectFactory9.create(isTransfer);
+
+// src/block/AllowedBlockPayload.ts
+var AllowedBlockPayloadSchemas = [
+  BoundWitnessSchema,
+  BridgeDestinationObservationSchema,
+  BridgeIntentSchema,
+  BridgeSourceObservationSchema,
+  ChainStakeIntentSchema,
+  HashSchema,
+  SchemaSchema,
+  StepCompleteSchema,
+  TimeSchema,
+  TransferSchema
+];
+var AllowedBlockPayloadSchemaZod = z14.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);
+};
+var isAllowedBlockPayloadWithHashMeta = (value) => {
+  return isAllowedBlockPayload(value) && isHashMeta(value);
+};
+
+// src/block/BlockBoundWitness.ts
+import {
+  HashZod as HashZod2,
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory6
+} from "@xylabs/sdk-js";
+import {
+  BoundWitnessZod as BoundWitnessZod2,
+  WithHashMetaZod as WithHashMetaZod2,
+  WithStorageMetaZod as WithStorageMetaZod2
+} from "@xyo-network/sdk-js";
+import { z as z15 } from "zod";
+var BlockBoundWitnessFieldsZod = z15.object({
+  block: XL1BlockNumberZod,
+  chain: ChainZod,
+  previous: HashZod2.nullable(),
+  protocol: z15.number().optional(),
+  step_hashes: z15.array(HashZod2).optional()
+});
+var BlockBoundWitnessMetaZod = z15.object({ $epoch: z15.number() });
+var BlockBoundWitnessZod = z15.object({
+  ...BoundWitnessZod2.shape,
+  ...BlockBoundWitnessFieldsZod.shape,
+  ...BlockBoundWitnessMetaZod.shape
+});
+var isBlockBoundWitness = zodIsFactory4(BlockBoundWitnessZod);
+var asBlockBoundWitness = zodAsFactory6(BlockBoundWitnessZod, "asBlockBoundWitness");
+var toBlockBoundWitness = zodToFactory6(BlockBoundWitnessZod, "toBlockBoundWitness");
+var BlockBoundWitnessWithHashMetaZod = WithHashMetaZod2(BlockBoundWitnessZod);
+var isBlockBoundWitnessWithHashMeta = zodIsFactory4(WithHashMetaZod2(BlockBoundWitnessZod));
+var asBlockBoundWitnessWithHashMeta = zodAsFactory6(WithHashMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithHashMeta");
+var toBlockBoundWitnessWithHashMeta = zodToFactory6(WithHashMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithHashMeta");
+var BlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod2(BlockBoundWitnessZod);
+var isBlockBoundWitnessWithStorageMeta = zodIsFactory4(WithStorageMetaZod2(BlockBoundWitnessZod));
+var asBlockBoundWitnessWithStorageMeta = zodAsFactory6(WithStorageMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithStorageMeta");
+var toBlockBoundWitnessWithStorageMeta = zodToFactory6(WithStorageMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithStorageMeta");
+
+// src/block/HydratedBlock.ts
+import {
+  zodAsFactory as zodAsFactory10,
+  zodIsFactory as zodIsFactory8,
+  zodToFactory as zodToFactory10
+} from "@xylabs/sdk-js";
+import {
+  PayloadZod,
+  PayloadZodLoose,
+  WithHashMetaZod as WithHashMetaZod4,
+  WithStorageMetaZod as WithStorageMetaZod4
+} from "@xyo-network/sdk-js";
+import { z as z16 } from "zod";
+
+// src/block/signed/SignedBlockBoundWitness.ts
+import {
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory5,
+  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);
+var isSignedBlockBoundWitness = zodIsFactory5(SignedBlockBoundWitnessZod);
+var asSignedBlockBoundWitness = zodAsFactory7(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
+var toSignedBlockBoundWitness = zodToFactory7(SignedBlockBoundWitnessZod, "toSignedBlockBoundWitness");
+
+// src/block/signed/SignedBlockBoundWitnessWithHashMeta.ts
+import {
+  zodAsFactory as zodAsFactory8,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory8
+} from "@xylabs/sdk-js";
+import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk-js";
+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 toSignedBlockBoundWitnessWithHashMeta = zodToFactory8(SignedBlockBoundWitnessWithHashMetaZod, "toSignedBlockBoundWitnessWithHashMeta");
+
+// src/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts
+import {
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory7,
+  zodToFactory as zodToFactory9
+} from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod3 } from "@xyo-network/sdk-js";
+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 toSignedBlockBoundWitnessWithStorageMeta = zodToFactory9(
+  SignedBlockBoundWitnessWithStorageMetaishZod,
+  "toSignedBlockBoundWitnessWithStorageMeta"
+);
+
+// src/block/HydratedBlock.ts
+var HydratedBlockZod = z16.tuple([
+  BlockBoundWitnessZod,
+  z16.array(PayloadZodLoose)
+]);
+var isHydratedBlock = zodIsFactory8(HydratedBlockZod);
+var asHydratedBlock = zodAsFactory10(HydratedBlockZod, "asHydratedBlock");
+var toHydratedBlock = zodToFactory10(HydratedBlockZod, "toHydratedBlock");
+var HydratedBlockWithHashMetaZod = z16.tuple([
+  WithHashMetaZod4(BlockBoundWitnessZod),
+  z16.array(WithHashMetaZod4(PayloadZod).loose())
+]);
+var isHydratedBlockWithHashMeta = zodIsFactory8(HydratedBlockWithHashMetaZod);
+var asHydratedBlockWithHashMeta = zodAsFactory10(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
+var toHydratedBlockWithHashMeta = zodToFactory10(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
+var HydratedBlockWithStorageMetaZod = z16.tuple([
+  WithStorageMetaZod4(BlockBoundWitnessZod),
+  z16.array(WithStorageMetaZod4(PayloadZod).loose())
+]);
+var isHydratedBlockWithStorageMeta = zodIsFactory8(HydratedBlockWithStorageMetaZod);
+var asHydratedBlockWithStorageMeta = zodAsFactory10(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
+var toHydratedBlockWithStorageMeta = zodToFactory10(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
+var SignedHydratedBlockZod = z16.tuple([
+  SignedBlockBoundWitnessZod,
+  z16.array(PayloadZod.loose())
+]);
+var isSignedHydratedBlock = zodIsFactory8(SignedHydratedBlockZod);
+var asSignedHydratedBlock = zodAsFactory10(SignedHydratedBlockZod, "asSignedHydratedBlock");
+var toSignedHydratedBlock = zodToFactory10(SignedHydratedBlockZod, "toSignedHydratedBlock");
+var SignedHydratedBlockToJsonZod = z16.tuple([
+  SignedBlockBoundWitnessZod,
+  z16.array(PayloadZod.loose())
+]);
+var isSignedHydratedBlockToJson = zodIsFactory8(SignedHydratedBlockToJsonZod);
+var asSignedHydratedBlockToJson = zodAsFactory10(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
+var toSignedHydratedBlockToJson = zodToFactory10(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
+var SignedHydratedBlockWithHashMetaZod = z16.tuple([
+  WithHashMetaZod4(SignedBlockBoundWitnessZod),
+  z16.array(WithHashMetaZod4(PayloadZod).loose())
+]);
+var SignedHydratedBlockWithHashMetaishZod = z16.tuple([
+  z16.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
+  z16.array(WithHashMetaZod4(PayloadZod).loose())
+]);
+var isSignedHydratedBlockWithHashMeta = zodIsFactory8(SignedHydratedBlockWithHashMetaZod);
+var asSignedHydratedBlockWithHashMeta = zodAsFactory10(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
+var toSignedHydratedBlockWithHashMeta = zodToFactory10(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
+var SignedHydratedBlockWithStorageMetaZod = z16.tuple([
+  WithStorageMetaZod4(SignedBlockBoundWitnessZod),
+  z16.array(WithStorageMetaZod4(PayloadZod).loose())
+]);
+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())
+]);
+
+// src/block/unsigned/UnsignedBlockBoundWitness.ts
+import {
+  zodAsFactory as zodAsFactory11,
+  zodIsFactory as zodIsFactory9,
+  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);
+var isUnsignedBlockBoundWitness = zodIsFactory9(UnsignedBlockBoundWitnessZod);
+var asUnsignedBlockBoundWitness = zodAsFactory11(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
+var toUnsignedBlockBoundWitness = zodToFactory11(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
+
+// src/fields/BlockNumber.ts
+import { AsObjectFactory as AsObjectFactory10 } from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema10,
+  isPayloadOfSchemaType as isPayloadOfSchemaType6,
+  isPayloadOfSchemaTypeWithSources
+} from "@xyo-network/sdk-js";
+var BlockNumberSchema = asSchema10("network.xyo.chain.block.number", true);
+var isBlockNumberPayload = isPayloadOfSchemaType6(BlockNumberSchema);
+var asBlockNumberPayload = AsObjectFactory10.create(isBlockNumberPayload);
+var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
+var asBlockNumberPayloadWithSources = AsObjectFactory10.create(isBlockNumberPayloadWithSources);
+
+// 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";
+
+// src/model/ChainQualification.ts
+import { HashZod as HashZod3, zodIsFactory as zodIsFactory11 } from "@xylabs/sdk-js";
+import { z as z21 } from "zod";
+
+// src/model/BlockRange/BlockRange.ts
+import {
+  assertError,
+  isDefined,
+  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]);
+var asBlockRange = zodAsFactory12(BlockRangeZod, "BlockRange");
+var toBlockRange = zodToFactory12(BlockRangeishZod, "BlockRange");
+var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
+function fromBlockNumberKey(key, assert) {
+  const [start, end] = key.split("|").map((v) => asBlockNumber(Number(v)));
+  const result = isDefined(start) && isDefined(end) ? [start, end] : void 0;
+  return assertError(result, assert, `Invalid BlockRangeKey: ${key}`);
+}
+
+// src/model/BlockRange/EthBlockRange.ts
+import {
+  assertError as assertError2,
+  isDefined as isDefined2,
+  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]);
+var asEthBlockRange = zodAsFactory13(EthBlockRangeZod, "EthBlockRange");
+var toEthBlockRange = zodToFactory13(EthBlockRangeishZod, "EthBlockRange");
+var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
+function fromEthBlockNumberKey(key, assert) {
+  const [start, end] = key.split("|").map((v) => asEthBlockNumber(Number(v)));
+  const result = isDefined2(start) && isDefined2(end) ? [start, end] : void 0;
+  return assertError2(result, assert, `Invalid EthBlockRangeKey: ${key}`);
+}
+
+// src/model/BlockRange/Range.ts
+import {
+  zodAsFactory as zodAsFactory14,
+  zodIsFactory as zodIsFactory10,
+  zodToFactory as zodToFactory14
+} from "@xylabs/sdk-js";
+import { z as z19 } from "zod";
+var RangeZod = z19.tuple([z19.number(), z19.number()]);
+var isRange = zodIsFactory10(RangeZod);
+var asRange = zodAsFactory14(RangeZod, "Range");
+var toRange = zodToFactory14(RangeZod, "Range");
+
+// src/model/BlockRange/XL1BlockRange.ts
+import {
+  assertError as assertError3,
+  isDefined as isDefined3,
+  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]);
+var asXL1BlockRange = zodAsFactory15(XL1BlockRangeZod, "XL1BlockRange");
+var toXL1BlockRange = zodToFactory15(XL1BlockRangeishZod, "XL1BlockRange");
+var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
+function fromXL1BlockNumberKey(key, assert) {
+  const [start, end] = key.split("|").map((v) => asXL1BlockNumber(Number(v)));
+  const result = isDefined3(start) && isDefined3(end) ? [start, end] : void 0;
+  return assertError3(result, assert, `Invalid XL1BlockRangeKey: ${key}`);
+}
+
+// src/model/ChainQualification.ts
+var ChainQualificationZod = z21.object({ head: HashZod3, range: XL1BlockRangeZod });
+var isChainQualification = zodIsFactory11(ChainQualificationZod);
+var ChainQualifiedRangeConfigZod = z21.object({ range: XL1BlockRangeZod });
+var isChainQualifiedRangeConfig = zodIsFactory11(ChainQualifiedRangeConfigZod);
+var ChainQualifiedHeadConfigZod = z21.object({ head: HashZod3 });
+var isChainQualifiedHeadConfig = zodIsFactory11(ChainQualifiedHeadConfigZod);
+var ChainQualifiedConfigZod = z21.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z21.object({})]);
+var isChainQualifiedConfig = zodIsFactory11(ChainQualifiedConfigZod);
+var ExtendChainQualifiedConfigZod = ((zodType) => {
+  return z21.union([
+    ChainQualifiedRangeConfigZod.extend(zodType),
+    ChainQualifiedHeadConfigZod.extend(zodType),
+    zodType
+  ]);
+});
+var ChainQualifiedZod = (zodType) => {
+  return z21.tuple([zodType, ChainQualificationZod]);
+};
+
+// src/model/AccountBalance.ts
+var AccountBalanceHistoryItemZod = z22.tuple([
+  WithHashMetaZod5(BlockBoundWitnessZod),
+  WithHashMetaZod5(TransactionBoundWitnessZod).nullable(),
+  WithHashMetaZod5(TransferZod)
+]);
+var AccountBalanceQualificationZod = ChainQualificationZod;
+var isAccountBalanceQualification = zodIsFactory12(AccountBalanceQualificationZod);
+var AccountBalanceConfigZod = ChainQualifiedConfigZod;
+var isAccountBalanceConfig = zodIsFactory12(AccountBalanceConfigZod);
+var AccountBalanceViewerMoniker = "AccountBalanceViewer";
+
+// src/model/addresses.ts
+var XYO_ZERO_ADDRESS = "0000000000000000000000000000000000000000";
+var XYO_BRIDGE_ADDRESS = "3012193230121932301219323012193230121932";
+var XYO_NETWORK_STAKING_ADDRESS = "1969196919691969196919691969196919691969";
+var XYO_STEP_REWARD_ADDRESS = "1216197612161976121619761216197612161976";
+var XL1_ETH_MAIN_ERC20_CONTRACT_ADDRESS = "0xf72aE3E0DA743033AbD7A407557D684c1aE66aed";
+var XL1_ETH_MAIN_SUB_GOVERNOR_ADDRESS = "0xbA296Bc5D0949C0484f08c56c30FB95CC4675A29";
+var XL1_ETH_MAIN_REWARDS_ADDRESS = "0x1a546e091FB4EFb274DC584334a28b8754c4ece7";
+var XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS = "0x319e667cED10452A117472811130444dED357F26";
+var XL1_ETH_MAIN_GOVERNANCE_ADDRESS = "0x7595710956d6B14b4f2F51a8dF41379eEeC9074E";
+
+// src/model/ArrayBuffer.ts
+import { z as z23 } 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 = z23.instanceof(ArrayBuffer).transform((x) => {
+  const u8 = new Uint8Array(x);
+  return base64Encode(u8);
+});
+var JsonToArrayBufferZod = z23.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()
+});
+var isTimeDurations = zodIsFactory13(TimeDurationsZod);
+var asTimeDurations = zodAsFactory16(TimeDurationsZod, "asTimeDurations");
+var toTimeDurations = zodAsFactory16(TimeDurationsZod, "toTimeDurations");
+var BlockRateZod = z24.object({
+  range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
+  rate: z24.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")
+});
+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({
+  minutes: timeUnitSchema.optional(),
+  hours: timeUnitSchema.optional(),
+  days: timeUnitSchema.optional(),
+  weeks: timeUnitSchema.optional(),
+  months: timeUnitSchema.optional(),
+  years: timeUnitSchema.optional()
+}).describe("Time configuration with optional time units");
+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 })
+]).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))
+);
+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({
+  caches: CachesZod.optional(),
+  logger: LoggerZod.optional(),
+  meterProvider: MeterProviderZod.optional(),
+  singletons: SingletonsZod,
+  timeBudgetLimit: TimeBudgetLimitZod.optional(),
+  traceProvider: TracerProviderZod.optional()
+});
+
+// src/model/Context/BlockContext.zod.ts
+import z26 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) }
+);
+var BlockContextWriteZod = CachingContextZod.extend(
+  { chainMap: z26.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(
+  { head: WithHashMetaZod6(BlockBoundWitnessZod) }
+);
+var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
+
+// src/model/Context/ChainContext.zod.ts
+var ChainContextReadZod = BlockContextReadZod.safeExtend(HeadContextBaseZod.shape);
+var ChainContextWriteZod = BlockContextWriteZod.safeExtend(
+  HeadContextBaseZod.shape
+);
+var ChainContextZod = BlockContextZod.safeExtend(
+  HeadContextBaseZod.shape
+);
+
+// src/model/defaultRewardRatio.ts
+var defaultRewardRatio = 0.05;
+
+// src/model/minTransactionFees.ts
+var minTransactionFees = {
+  base: AttoXL1(1000n * AttoXL1ConvertFactor.nano),
+  gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),
+  gasLimit: AttoXL1(1000000n * AttoXL1ConvertFactor.nano),
+  priority: AttoXL1(0n * AttoXL1ConvertFactor.nano)
+};
+
+// src/model/defaultTransactionFees.ts
+var defaultTransactionFees = {
+  base: minTransactionFees.base,
+  gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),
+  gasLimit: AttoXL1(1000000n * AttoXL1ConvertFactor.nano),
+  priority: minTransactionFees.priority
+};
+
+// src/model/HydratedTransaction.ts
+import {
+  zodAsFactory as zodAsFactory17,
+  zodIsFactory as zodIsFactory14,
+  zodToFactory as zodToFactory16
+} from "@xylabs/sdk-js";
+import {
+  PayloadZod as PayloadZod2,
+  PayloadZodLoose as PayloadZodLoose2,
+  WithHashMetaZod as WithHashMetaZod7,
+  WithStorageMetaZod as WithStorageMetaZod5
+} from "@xyo-network/sdk-js";
+import { z as z28 } from "zod";
+var HydratedTransactionZod = z28.tuple([
+  TransactionBoundWitnessZod,
+  z28.array(PayloadZodLoose2)
+]);
+var isHydratedTransaction = zodIsFactory14(HydratedTransactionZod);
+var asHydratedTransaction = zodAsFactory17(HydratedTransactionZod, "asHydratedTransaction");
+var toHydratedTransaction = zodToFactory16(HydratedTransactionZod, "toHydratedTransaction");
+var HydratedTransactionWithHashMetaZod = z28.tuple([
+  WithHashMetaZod7(TransactionBoundWitnessZod),
+  z28.array(WithHashMetaZod7(PayloadZod2).loose())
+]);
+var isHydratedTransactionWithHashMeta = zodIsFactory14(HydratedTransactionWithHashMetaZod);
+var asHydratedTransactionWithHashMeta = zodAsFactory17(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
+var toHydratedTransactionWithHashMeta = zodToFactory16(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
+var HydratedTransactionWithStorageMetaZod = z28.tuple([
+  WithStorageMetaZod5(TransactionBoundWitnessZod),
+  z28.array(WithStorageMetaZod5(PayloadZod2).loose())
+]);
+var isHydratedTransactionWithStorageMeta = zodIsFactory14(HydratedTransactionWithStorageMetaZod);
+var asHydratedTransactionWithStorageMeta = zodAsFactory17(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
+var toHydratedTransactionWithStorageMeta = zodToFactory16(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
+var UnsignedHydratedTransactionZod = z28.tuple([
+  UnsignedTransactionBoundWitnessZod,
+  z28.array(PayloadZodLoose2)
+]);
+var isUnsignedHydratedTransaction = zodIsFactory14(UnsignedHydratedTransactionZod);
+var asUnsignedHydratedTransaction = zodAsFactory17(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
+var toUnsignedHydratedTransaction = zodToFactory16(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
+var UnsignedHydratedTransactionWithHashMetaZod = z28.tuple([
+  WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
+  z28.array(WithHashMetaZod7(PayloadZod2).loose())
+]);
+var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory14(UnsignedHydratedTransactionWithHashMetaZod);
+var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory17(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
+var toUnsignedHydratedTransactionWithHashMeta = zodToFactory16(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
+var UnsignedHydratedTransactionWithStorageMetaZod = z28.tuple([
+  WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
+  z28.array(WithStorageMetaZod5(PayloadZod2).loose())
+]);
+var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory14(UnsignedHydratedTransactionWithStorageMetaZod);
+var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory17(
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  "asUnsignedHydratedTransactionWithStorageMeta"
+);
+var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory16(
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  "toUnsignedHydratedTransactionWithStorageMeta"
+);
+var SignedHydratedTransactionZod = z28.tuple([
+  SignedTransactionBoundWitnessZod,
+  z28.array(PayloadZodLoose2)
+]);
+var isSignedHydratedTransaction = zodIsFactory14(SignedHydratedTransactionZod);
+var asSignedHydratedTransaction = zodAsFactory17(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
+var toSignedHydratedTransaction = zodToFactory16(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
+var SignedHydratedTransactionWithHashMetaZod = z28.tuple([
+  WithHashMetaZod7(SignedTransactionBoundWitnessZod),
+  z28.array(WithHashMetaZod7(PayloadZod2).loose())
+]);
+var isSignedHydratedTransactionWithHashMeta = zodIsFactory14(SignedHydratedTransactionWithHashMetaZod);
+var asSignedHydratedTransactionWithHashMeta = zodAsFactory17(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
+var toSignedHydratedTransactionWithHashMeta = zodToFactory16(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
+var SignedHydratedTransactionWithStorageMetaZod = z28.tuple([
+  WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
+  z28.array(WithStorageMetaZod5(PayloadZod2).loose())
+]);
+var isSignedHydratedTransactionWithStorageMeta = zodIsFactory14(SignedHydratedTransactionWithStorageMetaZod);
+var asSignedHydratedTransactionWithStorageMeta = zodAsFactory17(
+  SignedHydratedTransactionWithStorageMetaZod,
+  "asSignedHydratedTransactionWithStorageMeta"
+);
+var toSignedHydratedTransactionWithStorageMeta = zodToFactory16(
+  SignedHydratedTransactionWithStorageMetaZod,
+  "toSignedHydratedTransactionWithStorageMeta"
+);
+
+// src/model/OpCodes.ts
+var ELEVATE_OPCODE = "elevate";
+
+// src/model/Permission.ts
+import { z as z29 } from "zod";
+var CaveatTypesZod = z29.enum(["chain", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z29.object({
+  type: CaveatTypesZod,
+  value: z29.json()
+});
+var PermissionZod = z29.object({
+  parentCapability: z29.string(),
+  caveats: CaveatsZod.array().optional(),
+  invoker: z29.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()
+});
+
+// src/model/rewards.ts
+import { toFixedPoint } from "@xylabs/sdk-js";
+var XL1_REWARDS_PLACES = 18;
+var XL1_REWARDS_STARTING_REWARD = asAttoXL1(toFixedPoint(500n, XL1_REWARDS_PLACES));
+var XL1_REWARDS_BLOCKS_PER_STEP = 1e6;
+var XL1_REWARDS_STEP_FACTOR_NUMERATOR = 95n;
+var XL1_REWARDS_STEP_FACTOR_DENOMINATOR = 100n;
+var XL1_REWARDS_MIN_BLOCK_REWARD = asAttoXL1(toFixedPoint(10n, XL1_REWARDS_PLACES));
+var XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20000000000n, XL1_REWARDS_PLACES));
+
+// 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(),
+  range: BlockRangeZod.optional(),
+  steps: z30.array(StepIdentityZod).optional(),
+  stakers: z30.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";
+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 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]);
+
+// 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({
+  amount: AttoZod,
+  // the block number when the stake was added
+  addBlock: z32.number(),
+  // the unique id for the stake item
+  id: z32.number(),
+  // the block number when the stake was removed (set to 0 if not removed)
+  removeBlock: z32.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()
+});
+var StakeToJsonZod = StakeZod.transform((val) => ({
+  addBlock: val.addBlock,
+  amount: BigIntToJsonZod2.parse(val.amount),
+  id: val.id,
+  removeBlock: val.removeBlock,
+  staked: AddressZod4.parse(val.staked),
+  staker: AddressZod4.parse(val.staker),
+  withdrawBlock: val.withdrawBlock
+}));
+var JsonToStakeZod = StakeZod.extend({ amount: HexZod6 }).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/model/TimeDomain.ts
+import { z as z33 } from "zod";
+var TimeDomainZod = z33.union([
+  z33.literal("xl1"),
+  z33.literal("epoch"),
+  z33.literal("ethereum")
+]);
+
+// src/model/TransferPair.ts
+import { AddressZod as AddressZod5 } from "@xylabs/sdk-js";
+import { z as z34 } from "zod";
+var TransferPairZod = z34.tuple([
+  AddressZod5,
+  AddressZod5
+]);
+
+// src/model/version.ts
+var XL1_PROTOCOL_VERSION_MAJOR = 1;
+var XL1_PROTOCOL_VERSION_MINOR = 2;
+var XL1_PROTOCOL_VERSION_PATCH = 0;
+var XL1_PROTOCOL_VERSION_STRING = `${XL1_PROTOCOL_VERSION_MAJOR}.${XL1_PROTOCOL_VERSION_MINOR}.${XL1_PROTOCOL_VERSION_PATCH}`;
+var XL1_PROTOCOL_VERSION = XL1_PROTOCOL_VERSION_MAJOR * 1e6 + XL1_PROTOCOL_VERSION_MINOR * 1e3 + XL1_PROTOCOL_VERSION_PATCH;
+
+// src/provider/ProviderMoniker.ts
+import { assertEx, isString } from "@xylabs/sdk-js";
+var asProviderMoniker = (value) => {
+  const moniker = isString(value) ? value : void 0;
+  return assertEx(moniker);
+};
+var DefaultProviderMoniker = "Provider";
+export {
+  AccountBalanceConfigZod,
+  AccountBalanceHistoryItemZod,
+  AccountBalanceQualificationZod,
+  AccountBalanceViewerMoniker,
+  AllowedBlockPayloadSchemaZod,
+  AllowedBlockPayloadSchemas,
+  ArrayBufferToJsonZod,
+  BigIntToJsonZod2 as AttoToJsonZod,
+  AttoXL1,
+  AttoXL1ConvertFactor,
+  AttoXL1MaxValue,
+  AttoZod,
+  BLOCK_NUMBER_ZERO,
+  BaseContextZod,
+  BlockBoundWitnessFieldsZod,
+  BlockBoundWitnessMetaZod,
+  BlockBoundWitnessWithHashMetaZod,
+  BlockBoundWitnessWithStorageMetaZod,
+  BlockBoundWitnessZod,
+  BlockContextReadZod,
+  BlockContextWriteZod,
+  BlockContextZod,
+  BlockDurationZod,
+  BlockEndZod,
+  BlockNumberSchema,
+  BlockNumberZod,
+  BlockNumberishZod,
+  BlockRangeZod,
+  BlockRangeishZod,
+  BlockRateZod,
+  BlockScriptsZod,
+  BlockStartZod,
+  BridgeDestinationObservationFieldsZod,
+  BridgeDestinationObservationSchema,
+  BridgeDetailsDestinationFieldsZod,
+  BridgeDetailsFieldsZod,
+  BridgeDetailsSourceFieldsZod,
+  BridgeIntentFieldsZod,
+  BridgeIntentSchema,
+  BridgeSourceObservationFieldsZod,
+  BridgeSourceObservationSchema,
+  CachesZod,
+  CachingContextZod,
+  CaveatTypesZod,
+  CaveatsZod,
+  ChainContextReadZod,
+  ChainContextWriteZod,
+  ChainContextZod,
+  ChainQualificationZod,
+  ChainQualifiedConfigZod,
+  ChainQualifiedHeadConfigZod,
+  ChainQualifiedRangeConfigZod,
+  ChainQualifiedZod,
+  ChainStakeIntentSchema,
+  ChainZod,
+  CountZod,
+  DefaultProviderMoniker,
+  ELEVATE_OPCODE,
+  ETH_BLOCK_NUMBER_ZERO,
+  EpochTimeFieldsZod,
+  EthBlockNumberZod,
+  EthBlockNumberishZod,
+  EthBlockRangeZod,
+  EthBlockRangeishZod,
+  EthereumTimeFieldsZod,
+  ExtendChainQualifiedConfigZod,
+  FemtoXL1,
+  FemtoXL1MaxValue,
+  HashSchema,
+  HeadContextBaseZod,
+  HeadContextZod,
+  HydratedBlockWithHashMetaZod,
+  HydratedBlockWithStorageMetaZod,
+  HydratedBlockZod,
+  HydratedTransactionWithHashMetaZod,
+  HydratedTransactionWithStorageMetaZod,
+  HydratedTransactionZod,
+  InvokerPermissionZod,
+  JsonToArrayBufferZod,
+  JsonToAttoZod,
+  JsonToStakeZod,
+  LocalSequenceFromStringZod,
+  LocalSequenceToStringZod,
+  LoggerZod,
+  MeterProviderZod,
+  MicroXL1,
+  MicroXL1MaxValue,
+  MilliXL1,
+  MilliXL1MaxValue,
+  NanoXL1,
+  NanoXL1MaxValue,
+  NumberishZod,
+  PermissionRequestZod,
+  PermissionZod,
+  PicoXL1,
+  PicoXL1MaxValue,
+  QualifiedSequenceFromStringZod,
+  QualifiedSequenceToStringZod,
+  RangeZod,
+  RequestedPermissionZod,
+  RewardsRangeOptionsZod,
+  SequenceFromStringZod,
+  SequenceToStringZod,
+  SignedBlockBoundWitnessWithHashMetaZod,
+  SignedBlockBoundWitnessWithHashMetaishZod,
+  SignedBlockBoundWitnessWithStorageMetaZod,
+  SignedBlockBoundWitnessWithStorageMetaishZod,
+  SignedBlockBoundWitnessZod,
+  SignedHydratedBlockToJsonZod,
+  SignedHydratedBlockWithHashMetaZod,
+  SignedHydratedBlockWithHashMetaishZod,
+  SignedHydratedBlockWithStorageMetaZod,
+  SignedHydratedBlockWithStorageMetaishZod,
+  SignedHydratedBlockZod,
+  SignedHydratedTransactionWithHashMetaZod,
+  SignedHydratedTransactionWithStorageMetaZod,
+  SignedHydratedTransactionZod,
+  SignedTransactionBoundWitnessWithHashMetaZod,
+  SignedTransactionBoundWitnessWithStorageMetaZod,
+  SignedTransactionBoundWitnessZod,
+  SingleTimeConfigZod,
+  SingletonsZod,
+  StakeToJsonZod,
+  StakeZod,
+  StepCompleteSchema,
+  StepIdentitySchema,
+  StepIdentityZod,
+  StepIndexZod,
+  StepRewardFractions,
+  StepSizes,
+  TimeBudgetLimitZod,
+  TimeConfigZod,
+  TimeDomainZod,
+  TimeDurationsZod,
+  TimeFieldsZod,
+  TimePayloadZod,
+  TimeSchema,
+  TracerProviderZod,
+  TransactionBoundWitnessFieldsZod,
+  TransactionBoundWitnessIdentityFields,
+  TransactionBoundWitnessWithHashMetaZod,
+  TransactionBoundWitnessWithStorageMetaZod,
+  TransactionBoundWitnessZod,
+  TransactionFeesBigIntToJsonZod,
+  TransactionFeesBigIntZod,
+  TransactionFeesHexZod,
+  TransactionFeesJsonToBigIntZod,
+  TransactionFeesZod,
+  TransactionGasCosts,
+  TransferFieldsZod,
+  TransferPairZod,
+  TransferSchema,
+  TransferZod,
+  UnsignedBlockBoundWitnessZod,
+  UnsignedHydratedTransactionWithHashMetaZod,
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  UnsignedHydratedTransactionZod,
+  UnsignedTransactionBoundWitnessWithHashMetaZod,
+  UnsignedTransactionBoundWitnessWithStorageMetaZod,
+  UnsignedTransactionBoundWitnessZod,
+  XL1,
+  XL1BlockNumberZod,
+  XL1BlockNumberishZod,
+  XL1BlockRangeZod,
+  XL1BlockRangeishZod,
+  XL1MaxValue,
+  XL1Places,
+  XL1TimeFieldsZod,
+  XL1_BLOCK_NUMBER_ZERO,
+  XL1_ETH_MAIN_ERC20_CONTRACT_ADDRESS,
+  XL1_ETH_MAIN_GOVERNANCE_ADDRESS,
+  XL1_ETH_MAIN_REWARDS_ADDRESS,
+  XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS,
+  XL1_ETH_MAIN_SUB_GOVERNOR_ADDRESS,
+  XL1_PROTOCOL_VERSION,
+  XL1_PROTOCOL_VERSION_MAJOR,
+  XL1_PROTOCOL_VERSION_MINOR,
+  XL1_PROTOCOL_VERSION_PATCH,
+  XL1_PROTOCOL_VERSION_STRING,
+  XL1_REWARDS_BLOCKS_PER_STEP,
+  XL1_REWARDS_CREATOR_REWARD,
+  XL1_REWARDS_MIN_BLOCK_REWARD,
+  XL1_REWARDS_PLACES,
+  XL1_REWARDS_STARTING_REWARD,
+  XL1_REWARDS_STEP_FACTOR_DENOMINATOR,
+  XL1_REWARDS_STEP_FACTOR_NUMERATOR,
+  XYO_BRIDGE_ADDRESS,
+  XYO_NETWORK_STAKING_ADDRESS,
+  XYO_STEP_REWARD_ADDRESS,
+  XYO_ZERO_ADDRESS,
+  asAttoXL1,
+  asBlockBoundWitness,
+  asBlockBoundWitnessWithHashMeta,
+  asBlockBoundWitnessWithStorageMeta,
+  asBlockNumber,
+  asBlockNumberPayload,
+  asBlockNumberPayloadWithSources,
+  asBlockRange,
+  asBlockRate,
+  asBridgeDestinationObservation,
+  asBridgeIntent,
+  asBridgeSourceObservation,
+  asChainStakeIntent,
+  asEthBlockNumber,
+  asEthBlockRange,
+  asExecutable,
+  asFemtoXL1,
+  asHashPayload,
+  asHashPayloadWithStorageMeta,
+  asHydratedBlock,
+  asHydratedBlockWithHashMeta,
+  asHydratedBlockWithStorageMeta,
+  asHydratedTransaction,
+  asHydratedTransactionWithHashMeta,
+  asHydratedTransactionWithStorageMeta,
+  asMicroXL1,
+  asMilliXL1,
+  asNanoXL1,
+  asPicoXL1,
+  asProviderMoniker,
+  asRange,
+  asSignedBlockBoundWitness,
+  asSignedBlockBoundWitnessWithHashMeta,
+  asSignedBlockBoundWitnessWithStorageMeta,
+  asSignedHydratedBlock,
+  asSignedHydratedBlockToJson,
+  asSignedHydratedBlockWithHashMeta,
+  asSignedHydratedBlockWithStorageMeta,
+  asSignedHydratedTransaction,
+  asSignedHydratedTransactionWithHashMeta,
+  asSignedHydratedTransactionWithStorageMeta,
+  asSignedTransactionBoundWitness,
+  asSignedTransactionBoundWitnessWithHashMeta,
+  asSignedTransactionBoundWitnessWithStorageMeta,
+  asSingleTimeConfig,
+  asStepComplete,
+  asStepIdentity,
+  asStepIdentityPayload,
+  asTimeConfig,
+  asTimeDurations,
+  asTimePayload,
+  asTimePayloadWithStorageMeta,
+  asTransactionBoundWitness,
+  asTransactionBoundWitnessWithHashMeta,
+  asTransactionBoundWitnessWithStorageMeta,
+  asTransactionFeesBigInt,
+  asTransactionFeesHex,
+  asTransfer,
+  asUnsignedBlockBoundWitness,
+  asUnsignedHydratedTransaction,
+  asUnsignedHydratedTransactionWithHashMeta,
+  asUnsignedHydratedTransactionWithStorageMeta,
+  asUnsignedTransactionBoundWitness,
+  asUnsignedTransactionBoundWitnessWithHashMeta,
+  asUnsignedTransactionBoundWitnessWithStorageMeta,
+  asValidStep,
+  asXL1,
+  asXL1BlockNumber,
+  asXL1BlockRange,
+  defaultRewardRatio,
+  defaultTransactionFees,
+  fromBlockNumberKey,
+  fromEthBlockNumberKey,
+  fromXL1BlockNumberKey,
+  hasFrom,
+  isAccountBalanceConfig,
+  isAccountBalanceQualification,
+  isAllowedBlockPayload,
+  isAllowedBlockPayloadSchema,
+  isAllowedBlockPayloadWithHashMeta,
+  isAttoXL1,
+  isBlockBoundWitness,
+  isBlockBoundWitnessWithHashMeta,
+  isBlockBoundWitnessWithStorageMeta,
+  isBlockNumberPayload,
+  isBlockNumberPayloadWithSources,
+  isBlockRate,
+  isBridgeDestinationObservation,
+  isBridgeIntent,
+  isBridgeSourceObservation,
+  isChainQualification,
+  isChainQualifiedConfig,
+  isChainQualifiedHeadConfig,
+  isChainQualifiedRangeConfig,
+  isChainStakeIntent,
+  isChainStakeIntentWithStorageMeta,
+  isExecutable,
+  isFemtoXL1,
+  isHashPayload,
+  isHydratedBlock,
+  isHydratedBlockWithHashMeta,
+  isHydratedBlockWithStorageMeta,
+  isHydratedTransaction,
+  isHydratedTransactionWithHashMeta,
+  isHydratedTransactionWithStorageMeta,
+  isMicroXL1,
+  isMilliXL1,
+  isNanoXL1,
+  isPicoXL1,
+  isRange,
+  isSafeEpoch,
+  isSignedBlockBoundWitness,
+  isSignedBlockBoundWitnessWithHashMeta,
+  isSignedBlockBoundWitnessWithStorageMeta,
+  isSignedHydratedBlock,
+  isSignedHydratedBlockToJson,
+  isSignedHydratedBlockWithHashMeta,
+  isSignedHydratedBlockWithStorageMeta,
+  isSignedHydratedTransaction,
+  isSignedHydratedTransactionWithHashMeta,
+  isSignedHydratedTransactionWithStorageMeta,
+  isSignedTransactionBoundWitness,
+  isSignedTransactionBoundWitnessWithHashMeta,
+  isSignedTransactionBoundWitnessWithStorageMeta,
+  isSingleTimeConfig,
+  isStepComplete,
+  isStepIdentityPayload,
+  isTimeConfig,
+  isTimeDurations,
+  isTimePayload,
+  isTransactionBoundWitness,
+  isTransactionBoundWitnessWithHashMeta,
+  isTransactionBoundWitnessWithStorageMeta,
+  isTransactionFeesBigInt,
+  isTransactionFeesHex,
+  isTransfer,
+  isUnsignedBlockBoundWitness,
+  isUnsignedHydratedTransaction,
+  isUnsignedHydratedTransactionWithHashMeta,
+  isUnsignedHydratedTransactionWithStorageMeta,
+  isUnsignedTransactionBoundWitness,
+  isUnsignedTransactionBoundWitnessWithHashMeta,
+  isUnsignedTransactionBoundWitnessWithStorageMeta,
+  isValidStep,
+  isXL1,
+  minTransactionFees,
+  stepSize,
+  toAttoXL1,
+  toBlockBoundWitness,
+  toBlockBoundWitnessWithHashMeta,
+  toBlockBoundWitnessWithStorageMeta,
+  toBlockNumber,
+  toBlockNumberKey,
+  toBlockRange,
+  toBlockRate,
+  toEthBlockNumber,
+  toEthBlockNumberKey,
+  toEthBlockRange,
+  toFemtoXL1,
+  toHydratedBlock,
+  toHydratedBlockWithHashMeta,
+  toHydratedBlockWithStorageMeta,
+  toHydratedTransaction,
+  toHydratedTransactionWithHashMeta,
+  toHydratedTransactionWithStorageMeta,
+  toMicroXL1,
+  toMilliXL1,
+  toNanoXL1,
+  toPicoXL1,
+  toRange,
+  toSignedBlockBoundWitness,
+  toSignedBlockBoundWitnessWithHashMeta,
+  toSignedBlockBoundWitnessWithStorageMeta,
+  toSignedHydratedBlock,
+  toSignedHydratedBlockToJson,
+  toSignedHydratedBlockWithHashMeta,
+  toSignedHydratedBlockWithStorageMeta,
+  toSignedHydratedTransaction,
+  toSignedHydratedTransactionWithHashMeta,
+  toSignedHydratedTransactionWithStorageMeta,
+  toSignedTransactionBoundWitness,
+  toSignedTransactionBoundWitnessWithHashMeta,
+  toSignedTransactionBoundWitnessWithStorageMeta,
+  toSingleTimeConfig,
+  toTimeConfig,
+  toTimeDurations,
+  toTransactionBoundWitness,
+  toTransactionBoundWitnessWithHashMeta,
+  toTransactionBoundWitnessWithStorageMeta,
+  toTransactionFeesBigInt,
+  toTransactionFeesHex,
+  toUnsignedBlockBoundWitness,
+  toUnsignedHydratedTransaction,
+  toUnsignedHydratedTransactionWithHashMeta,
+  toUnsignedHydratedTransactionWithStorageMeta,
+  toUnsignedTransactionBoundWitness,
+  toUnsignedTransactionBoundWitnessWithHashMeta,
+  toUnsignedTransactionBoundWitnessWithStorageMeta,
+  toXL1,
+  toXL1BlockNumber,
+  toXL1BlockNumberKey,
+  toXL1BlockRange
+};
+//# sourceMappingURL=index.mjs.map