@xyo-network/xl1-protocol 4.0.11 → 4.0.14

package/dist/neutral/protocol-model.mjs

@@ -0,0 +1,2047 @@
+// src/modules/protocol-model/block/AllowedBlockPayload.ts
+import { zodIsFactory as zodIsFactory4 } from "@ariestools/sdk";
+import {
+  BoundWitnessSchema,
+  isHashMeta,
+  isSchemaPayload,
+  SchemaSchema
+} from "@xyo-network/sdk";
+import { z as z26 } from "zod";
+
+// src/modules/protocol-model/payload/application/Exchange/ExchangeOutcome.ts
+import { AsObjectFactory, HashZod } from "@ariestools/sdk";
+import { asSchema, isPayloadOfZodType } from "@xyo-network/sdk";
+import { z } from "zod/mini";
+var ExchangeOutcomeSchema = asSchema("network.xyo.exchange.outcome", true);
+var ExchangeOutcomeFieldsZod = z.object({
+  /** Hash of the ExchangeTerms payload this outcome settles */
+  terms: HashZod,
+  /** Settlement result */
+  outcome: z.enum(["fulfilled", "rejected"])
+});
+var isExchangeOutcome = isPayloadOfZodType(
+  ExchangeOutcomeFieldsZod,
+  ExchangeOutcomeSchema
+);
+var asExchangeOutcome = AsObjectFactory.create(isExchangeOutcome);
+
+// src/modules/protocol-model/payload/application/Exchange/ExchangeTerms.ts
+import { AsObjectFactory as AsObjectFactory2, HashZod as HashZod2 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema2,
+  isPayloadOfZodType as isPayloadOfZodType2,
+  XyoAddressZod as XyoAddressZod2
+} from "@xyo-network/sdk";
+import { z as z10 } from "zod/mini";
+
+// src/modules/protocol-model/transaction/TransactionBoundWitness.ts
+import {
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory6
+} from "@ariestools/sdk";
+import {
+  BoundWitnessZod,
+  HashMetaZod,
+  SignedBoundWitnessZod,
+  StorageMetaZod,
+  UnsignedBoundWitnessZod,
+  WithHashMetaZod,
+  WithStorageMetaZod,
+  XyoAddressZod
+} from "@xyo-network/sdk";
+import { z as z9 } from "zod/mini";
+
+// src/modules/protocol-model/BlockNumber/BlockNumber.ts
+import { zodAsFactory, zodToFactory } from "@ariestools/sdk";
+import { z as z3 } from "zod";
+
+// src/modules/protocol-model/BlockNumber/Numberish.ts
+import { z as z2 } from "zod";
+var NumberishZod = z2.union([z2.number(), z2.string(), z2.bigint()]).transform((v) => typeof v === "bigint" || typeof v === "string" ? Number(v) : v).pipe(z2.number());
+
+// src/modules/protocol-model/BlockNumber/BlockNumber.ts
+var BlockNumberZod = z3.int().nonnegative().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/modules/protocol-model/BlockNumber/EthBlockNumber.ts
+import { zodAsFactory as zodAsFactory2, zodToFactory as zodToFactory2 } from "@ariestools/sdk";
+import { z as z4 } from "zod";
+var EthBlockNumberZod = z4.int().nonnegative().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/modules/protocol-model/BlockNumber/xl1BlockNumber.ts
+import { zodAsFactory as zodAsFactory3, zodToFactory as zodToFactory3 } from "@ariestools/sdk";
+import { z as z5 } from "zod";
+var XL1BlockNumberZod = z5.int().nonnegative().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/modules/protocol-model/chain/Chain.ts
+import { AddressRegEx, toAddress } from "@ariestools/sdk";
+import { z as z6 } from "zod";
+var ChainZod = z6.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
+
+// src/modules/protocol-model/chain/ChainId.ts
+import {
+  HexZod,
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory,
+  zodToFactory as zodToFactory4
+} from "@ariestools/sdk";
+var ChainIdZod = HexZod;
+var isChainId = zodIsFactory(ChainIdZod);
+var asChainId = zodAsFactory4(ChainIdZod, "asChainId");
+var toChainId = zodToFactory4(ChainIdZod, "toChainId");
+
+// src/modules/protocol-model/transaction/TransactionFees.ts
+import {
+  BigIntToJsonZod,
+  HexZod as HexZod2,
+  JsonToBigIntZod,
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory5
+} from "@ariestools/sdk";
+import { z as z8 } from "zod/mini";
+
+// src/modules/protocol-model/xl1/isXl1Factory.ts
+import { z as z7 } from "zod";
+
+// src/modules/protocol-model/xl1/xl1MaxValue.ts
+var xl1MaxValue = (places) => 10n ** (32n - places) - 1n;
+
+// src/modules/protocol-model/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 z7.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 z7.union([z7.bigint(), z7.number(), z7.string(), z7.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/modules/protocol-model/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/modules/protocol-model/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/modules/protocol-model/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/modules/protocol-model/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/modules/protocol-model/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/modules/protocol-model/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/modules/protocol-model/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/modules/protocol-model/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/modules/protocol-model/transaction/TransactionFees.ts
+import { BigIntToJsonZod as BigIntToJsonZod2 } from "@ariestools/sdk";
+var AttoZod = z8.bigint();
+var JsonToAttoZod = z8.pipe(JsonToBigIntZod, z8.transform((v) => asAttoXL1(v)));
+var TransactionFeesHexZod = z8.object({
+  base: HexZod2,
+  gasLimit: HexZod2,
+  gasPrice: HexZod2,
+  priority: HexZod2
+});
+var isTransactionFeesHex = zodIsFactory2(TransactionFeesHexZod);
+var asTransactionFeesHex = zodAsFactory5(TransactionFeesHexZod, "asTransactionFeesHex");
+var toTransactionFeesHex = zodToFactory5(TransactionFeesHexZod, "toTransactionFeesHex");
+var TransactionFeesBigIntZod = z8.object({
+  base: AttoZod,
+  gasLimit: AttoZod,
+  gasPrice: AttoZod,
+  priority: AttoZod
+});
+var isTransactionFeesBigInt = zodIsFactory2(TransactionFeesBigIntZod);
+var asTransactionFeesBigInt = zodAsFactory5(TransactionFeesBigIntZod, "asTransactionFeesBigInt");
+var toTransactionFeesBigInt = zodToFactory5(TransactionFeesBigIntZod, "toTransactionFeesBigInt");
+var TransactionFeesJsonToBigIntZod = z8.pipe(
+  TransactionFeesHexZod,
+  z8.transform((val) => ({
+    base: JsonToBigIntZod.parse(val.base),
+    gasLimit: JsonToBigIntZod.parse(val.gasLimit),
+    gasPrice: JsonToBigIntZod.parse(val.gasPrice),
+    priority: JsonToBigIntZod.parse(val.priority)
+  }))
+);
+var TransactionFeesBigIntToJsonZod = z8.pipe(
+  TransactionFeesBigIntZod,
+  z8.transform((val) => ({
+    base: BigIntToJsonZod.parse(val.base),
+    gasLimit: BigIntToJsonZod.parse(val.gasLimit),
+    gasPrice: BigIntToJsonZod.parse(val.gasPrice),
+    priority: BigIntToJsonZod.parse(val.priority)
+  }))
+);
+
+// src/modules/protocol-model/transaction/TransactionBoundWitness.ts
+var BlockStartZod = z9.object({ nbf: XL1BlockNumberZod });
+var BlockEndZod = z9.object({ exp: XL1BlockNumberZod });
+var BlockDurationZod = z9.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod });
+var BlockScriptsZod = z9.object({ script: z9.optional(z9.array(z9.string())) });
+var TransactionFeesZod = z9.object({ fees: TransactionFeesHexZod });
+var TransactionBoundWitnessIdentityFields = z9.object({ chain: ChainZod, from: XyoAddressZod });
+var TransactionBoundWitnessFieldsZod = z9.safeExtend(
+  z9.safeExtend(
+    z9.safeExtend(
+      z9.safeExtend(z9.object(), BlockDurationZod.shape),
+      TransactionFeesZod.shape
+    ),
+    TransactionBoundWitnessIdentityFields.shape
+  ),
+  BlockScriptsZod.shape
+);
+var TransactionBoundWitnessZod = z9.safeExtend(BoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
+var isTransactionBoundWitness = zodIsFactory3(TransactionBoundWitnessZod);
+var asTransactionBoundWitness = zodAsFactory6(TransactionBoundWitnessZod, "asTransactionBoundWitness");
+var toTransactionBoundWitness = zodToFactory6(TransactionBoundWitnessZod, "toTransactionBoundWitness");
+var TransactionBoundWitnessWithHashMetaZod = z9.safeExtend(TransactionBoundWitnessZod, HashMetaZod.shape);
+var isTransactionBoundWitnessWithHashMeta = zodIsFactory3(TransactionBoundWitnessWithHashMetaZod);
+var asTransactionBoundWitnessWithHashMeta = zodAsFactory6(TransactionBoundWitnessWithHashMetaZod, "asTransactionBoundWitnessWithHashMeta");
+var toTransactionBoundWitnessWithHashMeta = zodToFactory6(TransactionBoundWitnessWithHashMetaZod, "toTransactionBoundWitnessWithHashMeta");
+var TransactionBoundWitnessWithStorageMetaZod = z9.safeExtend(TransactionBoundWitnessZod, StorageMetaZod.shape);
+var isTransactionBoundWitnessWithStorageMeta = zodIsFactory3(TransactionBoundWitnessWithStorageMetaZod);
+var asTransactionBoundWitnessWithStorageMeta = zodAsFactory6(TransactionBoundWitnessWithStorageMetaZod, "asTransactionBoundWitnessWithStorageMeta");
+var toTransactionBoundWitnessWithStorageMeta = zodToFactory6(TransactionBoundWitnessWithStorageMetaZod, "toTransactionBoundWitnessWithStorageMeta");
+var UnsignedTransactionBoundWitnessZod = z9.safeExtend(UnsignedBoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
+var isUnsignedTransactionBoundWitness = zodIsFactory3(UnsignedTransactionBoundWitnessZod);
+var asUnsignedTransactionBoundWitness = zodAsFactory6(UnsignedTransactionBoundWitnessZod, "asUnsignedTransactionBoundWitness");
+var toUnsignedTransactionBoundWitness = zodToFactory6(UnsignedTransactionBoundWitnessZod, "toUnsignedTransactionBoundWitness");
+var UnsignedTransactionBoundWitnessWithHashMetaZod = z9.safeExtend(UnsignedTransactionBoundWitnessZod, HashMetaZod.shape);
+var isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory3(UnsignedTransactionBoundWitnessWithHashMetaZod);
+var asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory6(
+  UnsignedTransactionBoundWitnessWithHashMetaZod,
+  "asUnsignedTransactionBoundWitnessWithHashMeta"
+);
+var toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory6(
+  UnsignedTransactionBoundWitnessWithHashMetaZod,
+  "toUnsignedTransactionBoundWitnessWithHashMeta"
+);
+var UnsignedTransactionBoundWitnessWithStorageMetaZod = z9.safeExtend(UnsignedTransactionBoundWitnessZod, StorageMetaZod.shape);
+var isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory3(UnsignedTransactionBoundWitnessWithStorageMetaZod);
+var asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory6(
+  UnsignedTransactionBoundWitnessWithStorageMetaZod,
+  "asUnsignedTransactionBoundWitnessWithStorageMeta"
+);
+var toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory6(
+  UnsignedTransactionBoundWitnessWithStorageMetaZod,
+  "toUnsignedTransactionBoundWitnessWithStorageMeta"
+);
+var SignedTransactionBoundWitnessZod = z9.safeExtend(SignedBoundWitnessZod, TransactionBoundWitnessFieldsZod.shape);
+var isSignedTransactionBoundWitness = zodIsFactory3(SignedTransactionBoundWitnessZod);
+var asSignedTransactionBoundWitness = zodAsFactory6(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
+var toSignedTransactionBoundWitness = zodToFactory6(SignedTransactionBoundWitnessZod, "toSignedTransactionBoundWitness");
+var SignedTransactionBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedTransactionBoundWitnessZod);
+var isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory3(SignedTransactionBoundWitnessWithHashMetaZod);
+var asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory6(
+  SignedTransactionBoundWitnessWithHashMetaZod,
+  "asSignedTransactionBoundWitnessWithHashMeta"
+);
+var toSignedTransactionBoundWitnessWithHashMeta = zodToFactory6(
+  SignedTransactionBoundWitnessWithHashMetaZod,
+  "toSignedTransactionBoundWitnessWithHashMeta"
+);
+var SignedTransactionBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedTransactionBoundWitnessZod);
+var isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory3(SignedTransactionBoundWitnessWithStorageMetaZod);
+var asSignedTransactionBoundWitnessWithStorageMeta = zodAsFactory6(
+  SignedTransactionBoundWitnessWithStorageMetaZod,
+  "asSignedTransactionBoundWitnessWithStorageMeta"
+);
+var toSignedTransactionBoundWitnessWithStorageMeta = zodToFactory6(
+  SignedTransactionBoundWitnessWithStorageMetaZod,
+  "toSignedTransactionBoundWitnessWithStorageMeta"
+);
+
+// src/modules/protocol-model/payload/application/Exchange/ExchangeTerms.ts
+var ExchangeTermsSchema = asSchema2("network.xyo.exchange.terms", true);
+var ExchangeTermsFieldsZod = z10.extend(
+  z10.object({
+    /** Stable identifier for this exchange */
+    exchangeId: z10.string(),
+    /**
+     * Each party is a set of addresses (most parties have one wallet; a multi-sig org may have several).
+     * All addresses in the set must co-sign the party's secret reveal at settlement.
+     */
+    parties: z10.array(z10.array(XyoAddressZod2)).check(z10.minLength(2)),
+    /** One hash per party — the data hash of that party's PartySecretReveal payload */
+    partySecrets: z10.array(HashZod2),
+    /** Hashes of the asset payload(s) being exchanged */
+    assets: z10.array(HashZod2),
+    /** Optional — addresses whose signature on appraisal payloads is accepted */
+    appraisalAuthorities: z10.optional(z10.array(XyoAddressZod2)),
+    /** Optional — addresses whose signature on payment-receipt payloads is accepted */
+    paymentAuthorities: z10.optional(z10.array(XyoAddressZod2))
+  }),
+  BlockDurationZod.shape
+);
+var isExchangeTerms = isPayloadOfZodType2(
+  ExchangeTermsFieldsZod,
+  ExchangeTermsSchema
+);
+var asExchangeTerms = AsObjectFactory2.create(isExchangeTerms);
+
+// src/modules/protocol-model/payload/application/Exchange/PartySecretReveal.ts
+import { AsObjectFactory as AsObjectFactory3 } from "@ariestools/sdk";
+import { asSchema as asSchema3, isPayloadOfZodType as isPayloadOfZodType3 } from "@xyo-network/sdk";
+import { z as z11 } from "zod/mini";
+var PartySecretRevealSchema = asSchema3("network.xyo.exchange.party.secret", true);
+var PartySecretRevealFieldsZod = z11.object({
+  /** Random opaque value — the bytes don't matter; what matters is that the party signed them */
+  nonce: z11.string()
+});
+var isPartySecretReveal = isPayloadOfZodType3(
+  PartySecretRevealFieldsZod,
+  PartySecretRevealSchema
+);
+var asPartySecretReveal = AsObjectFactory3.create(isPartySecretReveal);
+
+// src/modules/protocol-model/payload/application/Ordinal/Inscription.ts
+import { AsObjectFactory as AsObjectFactory4 } from "@ariestools/sdk";
+import { asSchema as asSchema4, isPayloadOfZodType as isPayloadOfZodType4 } from "@xyo-network/sdk";
+import { z as z12 } from "zod/mini";
+var InscriptionSchema = asSchema4("network.xyo.ordinal.inscription", true);
+var InscriptionFieldsZod = z12.object({
+  /** MIME type of the inscribed content (e.g. 'text/plain', 'image/png', 'application/json') */
+  contentType: z12.string(),
+  /** Inscribed content — base64 for binary, raw for text/JSON */
+  content: z12.string()
+});
+var isInscription = isPayloadOfZodType4(InscriptionFieldsZod, InscriptionSchema);
+var asInscription = AsObjectFactory4.create(isInscription);
+
+// src/modules/protocol-model/payload/application/Ordinal/OrdinalTransfer.ts
+import { AsObjectFactory as AsObjectFactory5, HashZod as HashZod3 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema5,
+  isPayloadOfZodType as isPayloadOfZodType5,
+  XyoAddressZod as XyoAddressZod3
+} from "@xyo-network/sdk";
+import { z as z13 } from "zod/mini";
+var OrdinalTransferSchema = asSchema5("network.xyo.ordinal.transfer", true);
+var OrdinalTransferFieldsZod = z13.object({
+  /** Content-addressed hash of the target inscription payload */
+  inscriptionId: HashZod3,
+  /** Recipient address — declarative content; the current owner is derived structurally */
+  to: XyoAddressZod3
+});
+var isOrdinalTransfer = isPayloadOfZodType5(
+  OrdinalTransferFieldsZod,
+  OrdinalTransferSchema
+);
+var asOrdinalTransfer = AsObjectFactory5.create(isOrdinalTransfer);
+
+// src/modules/protocol-model/payload/application/Xrc20/Ticker.ts
+import { z as z14 } from "zod/mini";
+var TickerZod = z14.string().check(z14.minLength(1), z14.maxLength(8));
+
+// src/modules/protocol-model/payload/application/Xrc20/TokenAmount.ts
+import { z as z15 } from "zod/mini";
+var TokenAmountZod = z15.string().check(z15.regex(/^\d+$/));
+
+// src/modules/protocol-model/payload/application/Xrc20/TokenDeploy.ts
+import { AsObjectFactory as AsObjectFactory6 } from "@ariestools/sdk";
+import { asSchema as asSchema6, isPayloadOfZodType as isPayloadOfZodType6 } from "@xyo-network/sdk";
+import { z as z16 } from "zod/mini";
+var TokenDeploySchema = asSchema6("network.xyo.ordinal.token.deploy", true);
+var TokenDeployFieldsZod = z16.object({
+  /** Ticker symbol — case-folded by the indexer */
+  tick: TickerZod,
+  /** Total supply */
+  max: TokenAmountZod,
+  /** Per-mint cap */
+  lim: TokenAmountZod,
+  /** Optional decimals (0–18); defaults to 0 in the indexer */
+  decimals: z16.optional(z16.int().check(z16.gte(0), z16.lte(18)))
+});
+var isTokenDeploy = isPayloadOfZodType6(TokenDeployFieldsZod, TokenDeploySchema);
+var asTokenDeploy = AsObjectFactory6.create(isTokenDeploy);
+
+// src/modules/protocol-model/payload/application/Xrc20/TokenMint.ts
+import { AsObjectFactory as AsObjectFactory7 } from "@ariestools/sdk";
+import { asSchema as asSchema7, isPayloadOfZodType as isPayloadOfZodType7 } from "@xyo-network/sdk";
+import { z as z17 } from "zod/mini";
+var TokenMintSchema = asSchema7("network.xyo.ordinal.token.mint", true);
+var TokenMintFieldsZod = z17.object({
+  /** Ticker being minted */
+  tick: TickerZod,
+  /** Amount minted */
+  amt: TokenAmountZod
+});
+var isTokenMint = isPayloadOfZodType7(TokenMintFieldsZod, TokenMintSchema);
+var asTokenMint = AsObjectFactory7.create(isTokenMint);
+
+// src/modules/protocol-model/payload/application/Xrc20/TokenTransfer.ts
+import { AsObjectFactory as AsObjectFactory8 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema8,
+  isPayloadOfZodType as isPayloadOfZodType8,
+  XyoAddressZod as XyoAddressZod4
+} from "@xyo-network/sdk";
+import { z as z18 } from "zod/mini";
+var TokenTransferSchema = asSchema8("network.xyo.ordinal.token.transfer", true);
+var TokenTransferFieldsZod = z18.object({
+  /** Ticker being transferred */
+  tick: TickerZod,
+  /** Recipient address — declarative content; the sender is derived structurally */
+  to: XyoAddressZod4,
+  /** Amount transferred */
+  amt: TokenAmountZod
+});
+var isTokenTransfer = isPayloadOfZodType8(
+  TokenTransferFieldsZod,
+  TokenTransferSchema
+);
+var asTokenTransfer = AsObjectFactory8.create(isTokenTransfer);
+
+// src/modules/protocol-model/payload/elevatable/Bridge/BridgeDestinationObservation.ts
+import { AsObjectFactory as AsObjectFactory9, HexZod as HexZod4 } from "@ariestools/sdk";
+import { asSchema as asSchema9, isPayloadOfZodType as isPayloadOfZodType9 } from "@xyo-network/sdk";
+import { z as z20 } from "zod/mini";
+
+// src/modules/protocol-model/payload/elevatable/Bridge/BridgeDetails.ts
+import { HexZod as HexZod3 } from "@ariestools/sdk";
+import { z as z19 } from "zod/mini";
+var BridgeDetailsDestinationFieldsZod = z19.object({
+  /**
+   * Destination network
+   */
+  dest: HexZod3.check(z19.describe("The destination network identifier")),
+  /**
+   * Destination address (EOA or contract)
+   */
+  destAddress: HexZod3.check(z19.describe("The destination address (EOA or contract)")),
+  /**
+   * Token amount to bridge to destination
+   */
+  destAmount: HexZod3.check(z19.describe("The token amount to bridge to destination")),
+  /**
+   * Token being bridged to
+   */
+  destToken: HexZod3.check(z19.describe("The token being bridged to"))
+});
+var BridgeDetailsSourceFieldsZod = z19.object({
+  /**
+   * Source network
+   */
+  src: HexZod3.check(z19.describe("The source network identifier")),
+  /**
+   * Source address (EOA or contract)
+   */
+  srcAddress: HexZod3.check(z19.describe("The source address (EOA or contract)")),
+  /**
+   * Token amount to bridge from source
+   */
+  srcAmount: HexZod3.check(z19.describe("The token amount to bridge from source")),
+  /**
+   * Token being bridged from
+   */
+  srcToken: HexZod3.check(z19.describe("The token being bridged from"))
+});
+var BridgeDetailsFieldsZod = z19.extend(
+  BridgeDetailsSourceFieldsZod,
+  BridgeDetailsDestinationFieldsZod.shape
+);
+
+// src/modules/protocol-model/payload/elevatable/Bridge/BridgeDestinationObservation.ts
+var BridgeDestinationObservationSchema = asSchema9("network.xyo.chain.bridge.observation.destination", true);
+var BridgeDestinationObservationFieldsZod = z20.extend(BridgeDetailsFieldsZod, {
+  /**
+   * Destination chain confirmation
+   */
+  destConfirmation: z20.optional(HexZod4).check(z20.describe("Destination chain confirmation"))
+});
+var isBridgeDestinationObservation = isPayloadOfZodType9(
+  BridgeDestinationObservationFieldsZod,
+  BridgeDestinationObservationSchema
+);
+var asBridgeDestinationObservation = AsObjectFactory9.create(isBridgeDestinationObservation);
+
+// src/modules/protocol-model/payload/elevatable/Bridge/BridgeIntent.ts
+import { AsObjectFactory as AsObjectFactory10 } from "@ariestools/sdk";
+import { asSchema as asSchema10, isPayloadOfZodType as isPayloadOfZodType10 } from "@xyo-network/sdk";
+import { z as z21 } from "zod/mini";
+var BridgeIntentSchema = asSchema10("network.xyo.chain.bridge.intent", true);
+var BridgeIntentFieldsZod = z21.extend(BridgeDetailsFieldsZod, {
+  /**
+   * Unique identifier for replay protection
+   */
+  nonce: z21.string().check(z21.describe("Unique identifier for replay protection"))
+});
+var isBridgeIntent = isPayloadOfZodType10(
+  BridgeIntentFieldsZod,
+  BridgeIntentSchema
+);
+var asBridgeIntent = AsObjectFactory10.create(isBridgeIntent);
+
+// src/modules/protocol-model/payload/elevatable/Bridge/BridgeSourceObservation.ts
+import { AsObjectFactory as AsObjectFactory11, HexZod as HexZod5 } from "@ariestools/sdk";
+import { asSchema as asSchema11, isPayloadOfZodType as isPayloadOfZodType11 } from "@xyo-network/sdk";
+import { z as z22 } from "zod/mini";
+var BridgeSourceObservationSchema = asSchema11("network.xyo.chain.bridge.observation.source", true);
+var BridgeSourceObservationFieldsZod = z22.extend(BridgeDetailsFieldsZod, {
+  /**
+   * Source chain confirmation
+   */
+  srcConfirmation: z22.optional(HexZod5).check(z22.describe("Source chain confirmation"))
+});
+var isBridgeSourceObservation = isPayloadOfZodType11(
+  BridgeSourceObservationFieldsZod,
+  BridgeSourceObservationSchema
+);
+var asBridgeSourceObservation = AsObjectFactory11.create(isBridgeSourceObservation);
+
+// src/modules/protocol-model/payload/elevatable/ChainStakeIntent.ts
+import { AsObjectFactory as AsObjectFactory12 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema12,
+  isPayloadOfSchemaType,
+  isStorageMeta
+} from "@xyo-network/sdk";
+var ChainStakeIntentSchema = asSchema12("network.xyo.chain.stake.intent", true);
+var isChainStakeIntent = (x) => {
+  return isPayloadOfSchemaType(ChainStakeIntentSchema)(x) && asNonNegativeInteger(x.nbf) !== void 0 && asNonNegativeInteger(x.exp) !== void 0;
+};
+var asChainStakeIntent = AsObjectFactory12.create(isChainStakeIntent);
+var isChainStakeIntentWithStorageMeta = (x) => {
+  return isChainStakeIntent(x) && isStorageMeta(x);
+};
+var asNonNegativeInteger = (num) => {
+  return Number.isSafeInteger(num) && num >= 0 ? num : void 0;
+};
+
+// src/modules/protocol-model/payload/elevatable/Executable.ts
+import { isAnyPayload } from "@xyo-network/sdk";
+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/modules/protocol-model/payload/elevatable/Hash.ts
+import { AsObjectFactory as AsObjectFactory13 } from "@ariestools/sdk";
+import { asSchema as asSchema13, isPayloadOfSchemaType as isPayloadOfSchemaType2 } from "@xyo-network/sdk";
+var HashSchema = asSchema13("network.xyo.hash", true);
+var isHashPayload = isPayloadOfSchemaType2(HashSchema);
+var asHashPayload = AsObjectFactory13.create(isHashPayload);
+var asHashPayloadWithStorageMeta = AsObjectFactory13.create(isHashPayload);
+
+// src/modules/protocol-model/payload/elevatable/StepComplete.ts
+import { AsObjectFactory as AsObjectFactory14 } from "@ariestools/sdk";
+import { asSchema as asSchema14, isPayloadOfSchemaType as isPayloadOfSchemaType3 } from "@xyo-network/sdk";
+var StepCompleteSchema = asSchema14("network.xyo.chain.step.complete", true);
+var isStepComplete = isPayloadOfSchemaType3(StepCompleteSchema);
+var asStepComplete = AsObjectFactory14.create(isStepComplete);
+
+// src/modules/protocol-model/payload/elevatable/Time.ts
+import { AsObjectFactory as AsObjectFactory15, HashZod as HashZod4 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema15,
+  isPayloadOfSchemaType as isPayloadOfSchemaType4,
+  PayloadZodOfSchema
+} from "@xyo-network/sdk";
+import { z as z23 } from "zod/mini";
+var TimeSchema = asSchema15("network.xyo.time", true);
+var XL1TimeFieldsZod = z23.object({
+  // block number
+  xl1: z23.optional(z23.number()),
+  // block hash
+  xl1Hash: z23.optional(HashZod4)
+});
+var EthereumTimeFieldsZod = z23.object({
+  // block number
+  ethereum: z23.optional(z23.number()),
+  // block hash
+  ethereumHash: z23.optional(HashZod4)
+});
+var EpochTimeFieldsZod = z23.object({
+  // in milliseconds
+  epoch: z23.number()
+});
+var TimeFieldsZod = z23.extend(
+  z23.extend(z23.extend(XL1TimeFieldsZod, XL1TimeFieldsZod.shape), EthereumTimeFieldsZod.shape),
+  EpochTimeFieldsZod.shape
+);
+var TimePayloadZod = z23.extend(PayloadZodOfSchema(TimeSchema), 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 = AsObjectFactory15.create(isTimePayload);
+var asTimePayloadWithStorageMeta = AsObjectFactory15.create(isTimePayload);
+
+// src/modules/protocol-model/payload/StepIdentityPayload.ts
+import { AsObjectFactory as AsObjectFactory16 } from "@ariestools/sdk";
+import { asSchema as asSchema16, isPayloadOfZodType as isPayloadOfZodType12 } from "@xyo-network/sdk";
+
+// src/modules/protocol-model/Step/StepIdentity.ts
+import { isUndefined } from "@ariestools/sdk";
+import { z as z24 } from "zod";
+var StepIdentityZod = z24.object({
+  block: XL1BlockNumberZod.describe("The block number at which the step occurs"),
+  step: z24.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.isSafeInteger(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/modules/protocol-model/Step/StepSizes.ts
+import { AsTypeFactory } from "@ariestools/sdk";
+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.isSafeInteger(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/modules/protocol-model/payload/StepIdentityPayload.ts
+var StepIdentitySchema = asSchema16("network.xyo.chain.step.identity", true);
+var isStepIdentityPayload = isPayloadOfZodType12(StepIdentityZod, StepIdentitySchema);
+var asStepIdentityPayload = AsObjectFactory16.create(isStepIdentityPayload);
+
+// src/modules/protocol-model/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/modules/protocol-model/TransferPayload.ts
+import {
+  AsObjectFactory as AsObjectFactory17,
+  HexZod as HexZod6,
+  JsonObjectZod
+} from "@ariestools/sdk";
+import {
+  asSchema as asSchema17,
+  isPayloadOfSchemaType as isPayloadOfSchemaType5,
+  PayloadZodOfSchema as PayloadZodOfSchema2,
+  XyoAddressZod as XyoAddressZod5
+} from "@xyo-network/sdk";
+import { z as z25 } from "zod/mini";
+var TransferSchema = asSchema17("network.xyo.transfer", true);
+var TransferFieldsZod = z25.object({
+  // Removed as only transaction have opCodes
+  // $opCodes: z.array(z.string()).optional(),
+  context: z25.optional(JsonObjectZod),
+  epoch: z25.number(),
+  from: XyoAddressZod5,
+  transfers: z25.record(XyoAddressZod5, HexZod6)
+});
+var TransferZod = z25.extend(PayloadZodOfSchema2(TransferSchema), TransferFieldsZod.shape);
+var isTransfer = isPayloadOfSchemaType5(TransferSchema);
+var asTransfer = AsObjectFactory17.create(isTransfer);
+
+// src/modules/protocol-model/block/AllowedBlockPayload.ts
+var AllowedBlockPayloadSchemas = [
+  BoundWitnessSchema,
+  BridgeDestinationObservationSchema,
+  BridgeIntentSchema,
+  BridgeSourceObservationSchema,
+  ChainStakeIntentSchema,
+  HashSchema,
+  SchemaSchema,
+  StepCompleteSchema,
+  TimeSchema,
+  TransferSchema
+];
+var AllowedBlockPayloadSchemaZod = z26.enum(AllowedBlockPayloadSchemas);
+var isAllowedBlockPayloadSchema = zodIsFactory4(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/modules/protocol-model/block/BlockBoundWitness.ts
+import {
+  HashZod as HashZod5,
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory7
+} from "@ariestools/sdk";
+import {
+  BoundWitnessZod as BoundWitnessZod2,
+  WithHashMetaZod as WithHashMetaZod2,
+  WithStorageMetaZod as WithStorageMetaZod2
+} from "@xyo-network/sdk";
+import { z as z27 } from "zod/mini";
+var BlockBoundWitnessFieldsZod = z27.object({
+  block: XL1BlockNumberZod,
+  chain: ChainZod,
+  previous: z27.nullable(HashZod5),
+  protocol: z27.optional(z27.number()),
+  step_hashes: z27.optional(z27.array(HashZod5))
+});
+var BlockBoundWitnessMetaZod = z27.object({ $epoch: z27.number() });
+var BlockBoundWitnessZod = z27.object({
+  ...BoundWitnessZod2.shape,
+  ...BlockBoundWitnessFieldsZod.shape,
+  ...BlockBoundWitnessMetaZod.shape
+});
+var isBlockBoundWitness = zodIsFactory5(BlockBoundWitnessZod);
+var asBlockBoundWitness = zodAsFactory7(BlockBoundWitnessZod, "asBlockBoundWitness");
+var toBlockBoundWitness = zodToFactory7(BlockBoundWitnessZod, "toBlockBoundWitness");
+var BlockBoundWitnessWithHashMetaZod = WithHashMetaZod2(BlockBoundWitnessZod);
+var isBlockBoundWitnessWithHashMeta = zodIsFactory5(WithHashMetaZod2(BlockBoundWitnessZod));
+var asBlockBoundWitnessWithHashMeta = zodAsFactory7(WithHashMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithHashMeta");
+var toBlockBoundWitnessWithHashMeta = zodToFactory7(WithHashMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithHashMeta");
+var BlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod2(BlockBoundWitnessZod);
+var isBlockBoundWitnessWithStorageMeta = zodIsFactory5(WithStorageMetaZod2(BlockBoundWitnessZod));
+var asBlockBoundWitnessWithStorageMeta = zodAsFactory7(WithStorageMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithStorageMeta");
+var toBlockBoundWitnessWithStorageMeta = zodToFactory7(WithStorageMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithStorageMeta");
+
+// src/modules/protocol-model/block/HydratedBlock.ts
+import {
+  zodAsFactory as zodAsFactory11,
+  zodIsFactory as zodIsFactory9,
+  zodToFactory as zodToFactory11
+} from "@ariestools/sdk";
+import {
+  PayloadZod,
+  PayloadZodLoose,
+  WithHashMetaZod as WithHashMetaZod4,
+  WithStorageMetaZod as WithStorageMetaZod4
+} from "@xyo-network/sdk";
+import { z as z31 } from "zod/mini";
+
+// src/modules/protocol-model/block/signed/SignedBlockBoundWitness.ts
+import {
+  zodAsFactory as zodAsFactory8,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory8
+} from "@ariestools/sdk";
+import { SignedBoundWitnessZod as SignedBoundWitnessZod2 } from "@xyo-network/sdk";
+import { z as z28 } from "zod/mini";
+var SignedBlockBoundWitnessZod = z28.safeExtend(
+  z28.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+  BlockBoundWitnessMetaZod.shape
+);
+var isSignedBlockBoundWitness = zodIsFactory6(SignedBlockBoundWitnessZod);
+var asSignedBlockBoundWitness = zodAsFactory8(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
+var toSignedBlockBoundWitness = zodToFactory8(SignedBlockBoundWitnessZod, "toSignedBlockBoundWitness");
+
+// src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithHashMeta.ts
+import {
+  zodAsFactory as zodAsFactory9,
+  zodIsFactory as zodIsFactory7,
+  zodToFactory as zodToFactory9
+} from "@ariestools/sdk";
+import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk";
+import { z as z29 } from "zod/mini";
+var SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod3(SignedBlockBoundWitnessZod);
+var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory7(SignedBlockBoundWitnessWithHashMetaZod);
+var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory9(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
+var SignedBlockBoundWitnessWithHashMetaishZod = z29.pipe(
+  SignedBlockBoundWitnessZod,
+  z29.transform(async (data) => {
+    if (isSignedBlockBoundWitnessWithHashMeta(data)) {
+      return data;
+    }
+    if (isSignedBlockBoundWitness(data)) {
+      return await PayloadBuilder.addHashMeta(data);
+    }
+    throw new Error("Invalid SignedBlockBoundWitnessWithHashMetaish format");
+  })
+);
+var toSignedBlockBoundWitnessWithHashMeta = zodToFactory9(SignedBlockBoundWitnessWithHashMetaZod, "toSignedBlockBoundWitnessWithHashMeta");
+
+// src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts
+import {
+  zodAsFactory as zodAsFactory10,
+  zodIsFactory as zodIsFactory8,
+  zodToFactory as zodToFactory10
+} from "@ariestools/sdk";
+import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod3 } from "@xyo-network/sdk";
+import { z as z30 } from "zod/mini";
+var SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod3(SignedBlockBoundWitnessZod);
+var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory8(SignedBlockBoundWitnessWithStorageMetaZod);
+var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory10(
+  SignedBlockBoundWitnessWithStorageMetaZod,
+  "asSignedBlockBoundWitnessWithStorageMeta"
+);
+var SignedBlockBoundWitnessWithStorageMetaishZod = z30.pipe(
+  SignedBlockBoundWitnessZod,
+  z30.transform(async (data) => {
+    if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
+      return data;
+    }
+    if (isSignedBlockBoundWitness(data)) {
+      return await PayloadBuilder2.addStorageMeta(data);
+    }
+    throw new Error("Invalid SignedBlockBoundWitnessWithStorageMetaish format");
+  })
+);
+var toSignedBlockBoundWitnessWithStorageMeta = zodToFactory10(
+  SignedBlockBoundWitnessWithStorageMetaishZod,
+  "toSignedBlockBoundWitnessWithStorageMeta"
+);
+
+// src/modules/protocol-model/block/HydratedBlock.ts
+var HydratedBlockZod = z31.tuple([
+  BlockBoundWitnessZod,
+  z31.array(PayloadZodLoose)
+]);
+var isHydratedBlock = zodIsFactory9(HydratedBlockZod);
+var asHydratedBlock = zodAsFactory11(HydratedBlockZod, "asHydratedBlock");
+var toHydratedBlock = zodToFactory11(HydratedBlockZod, "toHydratedBlock");
+var HydratedBlockWithHashMetaZod = z31.tuple([
+  WithHashMetaZod4(BlockBoundWitnessZod),
+  z31.array(z31.looseObject(WithHashMetaZod4(PayloadZod).shape))
+]);
+var isHydratedBlockWithHashMeta = zodIsFactory9(HydratedBlockWithHashMetaZod);
+var asHydratedBlockWithHashMeta = zodAsFactory11(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
+var toHydratedBlockWithHashMeta = zodToFactory11(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
+var HydratedBlockWithStorageMetaZod = z31.tuple([
+  WithStorageMetaZod4(BlockBoundWitnessZod),
+  z31.array(z31.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+]);
+var isHydratedBlockWithStorageMeta = zodIsFactory9(HydratedBlockWithStorageMetaZod);
+var asHydratedBlockWithStorageMeta = zodAsFactory11(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
+var toHydratedBlockWithStorageMeta = zodToFactory11(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
+var SignedHydratedBlockZod = z31.tuple([
+  SignedBlockBoundWitnessZod,
+  z31.array(z31.looseObject(PayloadZod.shape))
+]);
+var isSignedHydratedBlock = zodIsFactory9(SignedHydratedBlockZod);
+var asSignedHydratedBlock = zodAsFactory11(SignedHydratedBlockZod, "asSignedHydratedBlock");
+var toSignedHydratedBlock = zodToFactory11(SignedHydratedBlockZod, "toSignedHydratedBlock");
+var SignedHydratedBlockToJsonZod = z31.tuple([
+  SignedBlockBoundWitnessZod,
+  z31.array(z31.looseObject(PayloadZod.shape))
+]);
+var isSignedHydratedBlockToJson = zodIsFactory9(SignedHydratedBlockToJsonZod);
+var asSignedHydratedBlockToJson = zodAsFactory11(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
+var toSignedHydratedBlockToJson = zodToFactory11(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
+var SignedHydratedBlockWithHashMetaZod = z31.tuple([
+  WithHashMetaZod4(SignedBlockBoundWitnessZod),
+  z31.array(z31.looseObject(WithHashMetaZod4(PayloadZod).shape))
+]);
+var SignedHydratedBlockWithHashMetaishZod = z31.tuple([
+  z31.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
+  z31.array(z31.looseObject(WithHashMetaZod4(PayloadZod).shape))
+]);
+var isSignedHydratedBlockWithHashMeta = zodIsFactory9(SignedHydratedBlockWithHashMetaZod);
+var asSignedHydratedBlockWithHashMeta = zodAsFactory11(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
+var toSignedHydratedBlockWithHashMeta = zodToFactory11(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
+var SignedHydratedBlockWithStorageMetaZod = z31.tuple([
+  WithStorageMetaZod4(SignedBlockBoundWitnessZod),
+  z31.array(z31.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+]);
+var isSignedHydratedBlockWithStorageMeta = zodIsFactory9(SignedHydratedBlockWithStorageMetaZod);
+var asSignedHydratedBlockWithStorageMeta = zodAsFactory11(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
+var toSignedHydratedBlockWithStorageMeta = zodToFactory11(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
+var SignedHydratedBlockWithStorageMetaishZod = z31.tuple([
+  z31.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
+  z31.array(z31.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+]);
+
+// src/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.ts
+import {
+  zodAsFactory as zodAsFactory12,
+  zodIsFactory as zodIsFactory10,
+  zodToFactory as zodToFactory12
+} from "@ariestools/sdk";
+import { UnsignedBoundWitnessZod as UnsignedBoundWitnessZod2 } from "@xyo-network/sdk";
+import { z as z32 } from "zod/mini";
+var UnsignedBlockBoundWitnessZod = z32.safeExtend(
+  z32.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+  BlockBoundWitnessMetaZod.shape
+);
+var isUnsignedBlockBoundWitness = zodIsFactory10(UnsignedBlockBoundWitnessZod);
+var asUnsignedBlockBoundWitness = zodAsFactory12(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
+var toUnsignedBlockBoundWitness = zodToFactory12(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
+
+// src/modules/protocol-model/fields/BlockNumber.ts
+import { AsObjectFactory as AsObjectFactory18 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema18,
+  isPayloadOfSchemaType as isPayloadOfSchemaType6,
+  isPayloadOfSchemaTypeWithSources
+} from "@xyo-network/sdk";
+var BlockNumberSchema = asSchema18("network.xyo.chain.block.number", true);
+var isBlockNumberPayload = isPayloadOfSchemaType6(BlockNumberSchema);
+var asBlockNumberPayload = AsObjectFactory18.create(isBlockNumberPayload);
+var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
+var asBlockNumberPayloadWithSources = AsObjectFactory18.create(isBlockNumberPayloadWithSources);
+
+// src/modules/protocol-model/model/AccountBalance.ts
+import { zodIsFactory as zodIsFactory13 } from "@ariestools/sdk";
+import { WithHashMetaZod as WithHashMetaZod5 } from "@xyo-network/sdk";
+import { z as z38 } from "zod/mini";
+
+// src/modules/protocol-model/model/ChainQualification.ts
+import { HashZod as HashZod6, zodIsFactory as zodIsFactory12 } from "@ariestools/sdk";
+import { z as z37 } from "zod";
+
+// src/modules/protocol-model/model/BlockRange/BlockRange.ts
+import {
+  assertError,
+  isDefined,
+  zodAsFactory as zodAsFactory13,
+  zodToFactory as zodToFactory13
+} from "@ariestools/sdk";
+import { z as z33 } from "zod";
+var BlockRangeZod = z33.tuple([BlockNumberZod, BlockNumberZod]);
+var BlockRangeishZod = z33.tuple([BlockNumberishZod, BlockNumberishZod]);
+var asBlockRange = zodAsFactory13(BlockRangeZod, "BlockRange");
+var toBlockRange = zodToFactory13(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/modules/protocol-model/model/BlockRange/EthBlockRange.ts
+import {
+  assertError as assertError2,
+  isDefined as isDefined2,
+  zodAsFactory as zodAsFactory14,
+  zodToFactory as zodToFactory14
+} from "@ariestools/sdk";
+import { z as z34 } from "zod";
+var EthBlockRangeZod = z34.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var EthBlockRangeishZod = z34.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
+var asEthBlockRange = zodAsFactory14(EthBlockRangeZod, "EthBlockRange");
+var toEthBlockRange = zodToFactory14(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/modules/protocol-model/model/BlockRange/Range.ts
+import {
+  zodAsFactory as zodAsFactory15,
+  zodIsFactory as zodIsFactory11,
+  zodToFactory as zodToFactory15
+} from "@ariestools/sdk";
+import { z as z35 } from "zod";
+var RangeZod = z35.tuple([z35.number(), z35.number()]);
+var isRange = zodIsFactory11(RangeZod);
+var asRange = zodAsFactory15(RangeZod, "Range");
+var toRange = zodToFactory15(RangeZod, "Range");
+
+// src/modules/protocol-model/model/BlockRange/xl1BlockRange.ts
+import {
+  assertError as assertError3,
+  isDefined as isDefined3,
+  zodAsFactory as zodAsFactory16,
+  zodToFactory as zodToFactory16
+} from "@ariestools/sdk";
+import { z as z36 } from "zod";
+var XL1BlockRangeZod = z36.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var XL1BlockRangeishZod = z36.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
+var asXL1BlockRange = zodAsFactory16(XL1BlockRangeZod, "XL1BlockRange");
+var toXL1BlockRange = zodToFactory16(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/modules/protocol-model/model/ChainQualification.ts
+var ChainQualificationZod = z37.object({ head: HashZod6, range: XL1BlockRangeZod });
+var isChainQualification = zodIsFactory12(ChainQualificationZod);
+var ChainQualifiedRangeConfigZod = z37.object({ range: XL1BlockRangeZod });
+var isChainQualifiedRangeConfig = zodIsFactory12(ChainQualifiedRangeConfigZod);
+var ChainQualifiedHeadConfigZod = z37.object({ head: HashZod6 });
+var isChainQualifiedHeadConfig = zodIsFactory12(ChainQualifiedHeadConfigZod);
+var ChainQualifiedConfigZod = z37.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z37.object({})]);
+var isChainQualifiedConfig = zodIsFactory12(ChainQualifiedConfigZod);
+var ExtendChainQualifiedConfigZod = ((zodType) => {
+  return z37.union([
+    ChainQualifiedRangeConfigZod.extend(zodType),
+    ChainQualifiedHeadConfigZod.extend(zodType),
+    zodType
+  ]);
+});
+var ChainQualifiedZod = (zodType) => {
+  return z37.tuple([zodType, ChainQualificationZod]);
+};
+
+// src/modules/protocol-model/model/AccountBalance.ts
+var AccountBalanceHistoryItemZod = z38.tuple([
+  WithHashMetaZod5(BlockBoundWitnessZod),
+  z38.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
+  WithHashMetaZod5(TransferZod)
+]);
+var AccountBalanceConfigZod = ChainQualifiedConfigZod;
+var isAccountBalanceConfig = zodIsFactory13(AccountBalanceConfigZod);
+var AccountBalanceViewerMoniker = "AccountBalanceViewer";
+
+// src/modules/protocol-model/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/modules/protocol-model/model/ArrayBuffer.ts
+import { z as z39 } from "zod";
+function base64Encode(u8) {
+  return u8.toBase64();
+}
+function base64Decode(b64) {
+  return Uint8Array.fromBase64(b64);
+}
+var ArrayBufferToJsonZod = z39.instanceof(ArrayBuffer).transform((x) => {
+  const u8 = new Uint8Array(x);
+  return base64Encode(u8);
+});
+var JsonToArrayBufferZod = z39.string().transform((x) => {
+  const u8 = base64Decode(x);
+  return u8.buffer;
+});
+
+// src/modules/protocol-model/model/BlockRate.ts
+import { zodAsFactory as zodAsFactory17, zodIsFactory as zodIsFactory14 } from "@ariestools/sdk";
+import { z as z40 } from "zod";
+var TimeDurationsZod = z40.object({
+  millis: z40.number().nonnegative(),
+  seconds: z40.number().nonnegative(),
+  minutes: z40.number().nonnegative(),
+  hours: z40.number().nonnegative(),
+  days: z40.number().nonnegative(),
+  weeks: z40.number().nonnegative()
+});
+var isTimeDurations = zodIsFactory14(TimeDurationsZod);
+var asTimeDurations = zodAsFactory17(TimeDurationsZod, "asTimeDurations");
+var toTimeDurations = zodAsFactory17(TimeDurationsZod, "toTimeDurations");
+var BlockRateZod = z40.object({
+  range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
+  rate: z40.number().nonnegative().describe("rate of blocks per specified time unit"),
+  timeUnit: TimeDurationsZod.keyof().describe("the unit of time for the rate and timePerBlock"),
+  span: z40.int().nonnegative().describe("number of blocks the rate was calculated over"),
+  timeDifference: z40.number().nonnegative().describe("time difference from start and end block"),
+  timePerBlock: z40.number().nonnegative().describe("average time per block for the given range")
+});
+var isBlockRate = zodIsFactory14(BlockRateZod);
+var asBlockRate = zodAsFactory17(BlockRateZod, "asBlockRate");
+var toBlockRate = zodAsFactory17(BlockRateZod, "toBlockRate");
+var CountZod = z40.int().nonnegative().describe("A non-negative integer count");
+var StepIndexZod = z40.int().min(0).max(StepSizes.length).describe("A non-negative integer step index");
+var timeUnitSchema = z40.number().positive();
+var TimeConfigZod = z40.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 = zodIsFactory14(TimeConfigZod);
+var asTimeConfig = zodAsFactory17(TimeConfigZod, "asTimeConfig");
+var toTimeConfig = zodAsFactory17(TimeConfigZod, "toTimeConfig");
+var SingleTimeConfigZod = z40.union([
+  z40.object({ minutes: timeUnitSchema }),
+  z40.object({ hours: timeUnitSchema }),
+  z40.object({ days: timeUnitSchema }),
+  z40.object({ weeks: timeUnitSchema }),
+  z40.object({ months: timeUnitSchema }),
+  z40.object({ years: timeUnitSchema })
+]).describe("Time configuration with exactly one time unit");
+var isSingleTimeConfig = zodIsFactory14(SingleTimeConfigZod);
+var asSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "asSingleTimeConfig");
+var toSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "toSingleTimeConfig");
+
+// src/modules/protocol-model/model/Context/BaseContext.zod.ts
+import { z as z41 } from "zod";
+var CachesZod = z41.record(
+  z41.string(),
+  z41.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
+);
+var SingletonsZod = z41.record(z41.union([z41.string(), z41.symbol()]), z41.unknown());
+var LoggerZod = z41.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
+var MeterProviderZod = z41.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
+var TracerProviderZod = z41.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
+var TimeBudgetLimitZod = z41.number();
+var BaseContextZod = z41.object({
+  caches: CachesZod.optional(),
+  logger: LoggerZod.optional(),
+  meterProvider: MeterProviderZod.optional(),
+  singletons: SingletonsZod,
+  timeBudgetLimit: TimeBudgetLimitZod.optional(),
+  traceProvider: TracerProviderZod.optional()
+});
+
+// src/modules/protocol-model/model/Context/BlockContext.zod.ts
+import z42 from "zod";
+
+// src/modules/protocol-model/model/Context/CachingContext.zod.ts
+var CachingContextZod = BaseContextZod.extend({ caches: CachesZod });
+
+// src/modules/protocol-model/model/Context/BlockContext.zod.ts
+var BlockContextReadZod = CachingContextZod.extend(
+  { chainMap: z42.custom((val) => val != null && typeof val === "object" && "get" in val) }
+);
+var BlockContextWriteZod = CachingContextZod.extend(
+  { chainMap: z42.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
+);
+var BlockContextZod = BlockContextWriteZod;
+
+// src/modules/protocol-model/model/Context/HeadContext.zod.ts
+import { WithHashMetaZod as WithHashMetaZod6 } from "@xyo-network/sdk";
+import z43 from "zod";
+var HeadContextBaseZod = z43.object(
+  { head: WithHashMetaZod6(BlockBoundWitnessZod) }
+);
+var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
+
+// src/modules/protocol-model/model/Context/ChainContext.zod.ts
+var ChainContextReadZod = BlockContextReadZod.safeExtend(HeadContextBaseZod.shape);
+var ChainContextWriteZod = BlockContextWriteZod.safeExtend(
+  HeadContextBaseZod.shape
+);
+var ChainContextZod = BlockContextZod.safeExtend(
+  HeadContextBaseZod.shape
+);
+
+// src/modules/protocol-model/model/defaultRewardRatio.ts
+var defaultRewardRatio = 0.05;
+
+// src/modules/protocol-model/model/minTransactionFees.ts
+var minTransactionFees = {
+  base: AttoXL1(1000n * AttoXL1ConvertFactor.nano),
+  gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),
+  gasLimit: AttoXL1(10n * AttoXL1ConvertFactor.nano),
+  priority: AttoXL1(0n * AttoXL1ConvertFactor.nano)
+};
+
+// src/modules/protocol-model/model/defaultTransactionFees.ts
+var defaultTransactionFees = {
+  base: minTransactionFees.base,
+  gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),
+  gasLimit: AttoXL1(1000n * AttoXL1ConvertFactor.nano),
+  priority: minTransactionFees.priority
+};
+
+// src/modules/protocol-model/model/HydratedTransaction.ts
+import {
+  zodAsFactory as zodAsFactory18,
+  zodIsFactory as zodIsFactory15,
+  zodToFactory as zodToFactory17
+} from "@ariestools/sdk";
+import {
+  PayloadZod as PayloadZod2,
+  PayloadZodLoose as PayloadZodLoose2,
+  WithHashMetaZod as WithHashMetaZod7,
+  WithStorageMetaZod as WithStorageMetaZod5
+} from "@xyo-network/sdk";
+import { z as z44 } from "zod/mini";
+var HydratedTransactionZod = z44.tuple([
+  TransactionBoundWitnessZod,
+  z44.array(PayloadZodLoose2)
+]);
+var isHydratedTransaction = zodIsFactory15(HydratedTransactionZod);
+var asHydratedTransaction = zodAsFactory18(HydratedTransactionZod, "asHydratedTransaction");
+var toHydratedTransaction = zodToFactory17(HydratedTransactionZod, "toHydratedTransaction");
+var HydratedTransactionWithHashMetaZod = z44.tuple([
+  WithHashMetaZod7(TransactionBoundWitnessZod),
+  z44.array(z44.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+]);
+var isHydratedTransactionWithHashMeta = zodIsFactory15(HydratedTransactionWithHashMetaZod);
+var asHydratedTransactionWithHashMeta = zodAsFactory18(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
+var toHydratedTransactionWithHashMeta = zodToFactory17(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
+var HydratedTransactionWithStorageMetaZod = z44.tuple([
+  WithStorageMetaZod5(TransactionBoundWitnessZod),
+  z44.array(z44.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+]);
+var isHydratedTransactionWithStorageMeta = zodIsFactory15(HydratedTransactionWithStorageMetaZod);
+var asHydratedTransactionWithStorageMeta = zodAsFactory18(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
+var toHydratedTransactionWithStorageMeta = zodToFactory17(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
+var UnsignedHydratedTransactionZod = z44.tuple([
+  UnsignedTransactionBoundWitnessZod,
+  z44.array(PayloadZodLoose2)
+]);
+var isUnsignedHydratedTransaction = zodIsFactory15(UnsignedHydratedTransactionZod);
+var asUnsignedHydratedTransaction = zodAsFactory18(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
+var toUnsignedHydratedTransaction = zodToFactory17(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
+var UnsignedHydratedTransactionWithHashMetaZod = z44.tuple([
+  WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
+  z44.array(z44.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+]);
+var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory15(UnsignedHydratedTransactionWithHashMetaZod);
+var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory18(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
+var toUnsignedHydratedTransactionWithHashMeta = zodToFactory17(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
+var UnsignedHydratedTransactionWithStorageMetaZod = z44.tuple([
+  WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
+  z44.array(z44.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+]);
+var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory15(UnsignedHydratedTransactionWithStorageMetaZod);
+var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory18(
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  "asUnsignedHydratedTransactionWithStorageMeta"
+);
+var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory17(
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  "toUnsignedHydratedTransactionWithStorageMeta"
+);
+var SignedHydratedTransactionZod = z44.tuple([
+  SignedTransactionBoundWitnessZod,
+  z44.array(PayloadZodLoose2)
+]);
+var isSignedHydratedTransaction = zodIsFactory15(SignedHydratedTransactionZod);
+var asSignedHydratedTransaction = zodAsFactory18(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
+var toSignedHydratedTransaction = zodToFactory17(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
+var SignedHydratedTransactionWithHashMetaZod = z44.tuple([
+  WithHashMetaZod7(SignedTransactionBoundWitnessZod),
+  z44.array(z44.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+]);
+var isSignedHydratedTransactionWithHashMeta = zodIsFactory15(SignedHydratedTransactionWithHashMetaZod);
+var asSignedHydratedTransactionWithHashMeta = zodAsFactory18(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
+var toSignedHydratedTransactionWithHashMeta = zodToFactory17(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
+var SignedHydratedTransactionWithStorageMetaZod = z44.tuple([
+  WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
+  z44.array(z44.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+]);
+var isSignedHydratedTransactionWithStorageMeta = zodIsFactory15(SignedHydratedTransactionWithStorageMetaZod);
+var asSignedHydratedTransactionWithStorageMeta = zodAsFactory18(
+  SignedHydratedTransactionWithStorageMetaZod,
+  "asSignedHydratedTransactionWithStorageMeta"
+);
+var toSignedHydratedTransactionWithStorageMeta = zodToFactory17(
+  SignedHydratedTransactionWithStorageMetaZod,
+  "toSignedHydratedTransactionWithStorageMeta"
+);
+
+// src/modules/protocol-model/model/OpCodes.ts
+var ELEVATE_OPCODE = "elevate";
+
+// src/modules/protocol-model/model/Permission.ts
+import { z as z45 } from "zod";
+var CaveatTypesZod = z45.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z45.object({
+  type: CaveatTypesZod,
+  value: z45.json()
+});
+var PermissionZod = z45.object({
+  parentCapability: z45.string(),
+  caveats: CaveatsZod.array().optional(),
+  invoker: z45.string()
+});
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z45.number().optional() });
+var PermissionRequestZod = z45.record(z45.string(), z45.record(z45.string(), z45.any()));
+var RequestedPermissionZod = z45.object({
+  parentCapability: z45.string(),
+  date: z45.number().optional()
+});
+
+// src/modules/protocol-model/model/rewards.ts
+import { toFixedPoint } from "@ariestools/sdk";
+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/modules/protocol-model/model/RewardsRangeOptions.ts
+import { XyoAddressZod as XyoAddressZod6 } from "@xyo-network/sdk";
+import { z as z46 } from "zod";
+var RewardsRangeOptionsZod = z46.object({
+  positions: z46.array(z46.number()).optional(),
+  range: BlockRangeZod.optional(),
+  steps: z46.array(StepIdentityZod).optional(),
+  stakers: z46.array(XyoAddressZod6).optional()
+});
+
+// src/modules/protocol-model/model/Sequence.ts
+import { HexRegExMinMax, toHex } from "@ariestools/sdk";
+import { SequenceConstants } from "@xyo-network/sdk";
+import { z as z47 } from "zod";
+var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
+var LocalSequenceToStringZod = z47.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z47.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
+var QualifiedSequenceToStringZod = z47.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z47.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z47.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z47.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+
+// src/modules/protocol-model/model/Stake.ts
+import { HexZod as HexZod7 } from "@ariestools/sdk";
+import { XyoAddressZod as XyoAddressZod7 } from "@xyo-network/sdk";
+import { z as z48 } from "zod";
+var StakeZod = z48.object({
+  amount: AttoZod,
+  // the block number when the stake was added
+  addBlock: z48.number(),
+  // the unique id for the stake item
+  id: z48.number(),
+  // the block number when the stake was removed (set to 0 if not removed)
+  removeBlock: z48.number(),
+  // the address that is being staked
+  staked: XyoAddressZod7,
+  // the address that owns the stake
+  staker: XyoAddressZod7,
+  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
+  withdrawBlock: z48.number()
+});
+var StakeToJsonZod = StakeZod.transform((val) => ({
+  addBlock: val.addBlock,
+  amount: BigIntToJsonZod2.parse(val.amount),
+  id: val.id,
+  removeBlock: val.removeBlock,
+  staked: XyoAddressZod7.parse(val.staked),
+  staker: XyoAddressZod7.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/modules/protocol-model/model/SyncStepSummary.ts
+import {
+  zodAsFactory as zodAsFactory19,
+  zodIsFactory as zodIsFactory16,
+  zodToFactory as zodToFactory18
+} from "@ariestools/sdk";
+import { z as z49 } from "zod";
+var SyncStepSummaryMetadataZod = z49.object({
+  block: XL1BlockNumberZod,
+  blockCount: z49.int().nonnegative(),
+  bytes: z49.int().nonnegative(),
+  createdAt: z49.string(),
+  endBlock: XL1BlockNumberZod,
+  relativePath: z49.string(),
+  startBlock: XL1BlockNumberZod,
+  step: z49.int().nonnegative(),
+  stepSize: XL1BlockNumberZod,
+  updatedAt: z49.string()
+});
+var isSyncStepSummaryMetadata = zodIsFactory16(SyncStepSummaryMetadataZod);
+var asSyncStepSummaryMetadata = zodAsFactory19(SyncStepSummaryMetadataZod, "asSyncStepSummaryMetadata");
+var toSyncStepSummaryMetadata = zodToFactory18(SyncStepSummaryMetadataZod, "toSyncStepSummaryMetadata");
+var SyncStepSummaryStatusZod = z49.object({
+  currentBlock: z49.optional(XL1BlockNumberZod),
+  isIndexing: z49.boolean(),
+  nextBoundaries: z49.record(z49.string(), XL1BlockNumberZod),
+  summaries: z49.array(SyncStepSummaryMetadataZod),
+  summaryCount: z49.int().nonnegative()
+});
+var isSyncStepSummaryStatus = zodIsFactory16(SyncStepSummaryStatusZod);
+var asSyncStepSummaryStatus = zodAsFactory19(SyncStepSummaryStatusZod, "asSyncStepSummaryStatus");
+var toSyncStepSummaryStatus = zodToFactory18(SyncStepSummaryStatusZod, "toSyncStepSummaryStatus");
+var SyncStepSummaryZod = z49.array(SignedHydratedBlockWithHashMetaZod);
+var isSyncStepSummary = zodIsFactory16(SyncStepSummaryZod);
+var asSyncStepSummary = zodAsFactory19(SyncStepSummaryZod, "asSyncStepSummary");
+var toSyncStepSummary = zodToFactory18(SyncStepSummaryZod, "toSyncStepSummary");
+
+// src/modules/protocol-model/model/TimeDomain.ts
+import { z as z50 } from "zod";
+var TimeDomainZod = z50.union([
+  z50.literal("xl1"),
+  z50.literal("epoch"),
+  z50.literal("ethereum")
+]);
+
+// src/modules/protocol-model/model/TransferPair.ts
+import { XyoAddressZod as XyoAddressZod8 } from "@xyo-network/sdk";
+import { z as z51 } from "zod";
+var TransferPairZod = z51.tuple([
+  XyoAddressZod8,
+  XyoAddressZod8
+]);
+
+// src/modules/protocol-model/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/modules/protocol-model/provider/ProviderMoniker.ts
+import { assertEx, isString } from "@ariestools/sdk";
+var asProviderMoniker = (value) => {
+  const moniker = isString(value) ? value : void 0;
+  return assertEx(moniker);
+};
+var DefaultProviderMoniker = "Provider";
+
+// src/modules/protocol-model/rejection/BlockRejectionPayload.ts
+import { AsObjectFactory as AsObjectFactory19 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema19,
+  isPayloadOfSchemaType as isPayloadOfSchemaType7,
+  PayloadZodOfSchema as PayloadZodOfSchema3
+} from "@xyo-network/sdk";
+import { z as z53 } from "zod/mini";
+
+// src/modules/protocol-model/rejection/RejectionError.ts
+import { HashZod as HashZod7 } from "@ariestools/sdk";
+import { z as z52 } from "zod";
+var RejectionErrorZod = z52.object({
+  hash: HashZod7,
+  message: z52.string().optional(),
+  name: z52.string()
+}).loose();
+
+// src/modules/protocol-model/rejection/BlockRejectionPayload.ts
+var BlockRejectionSchema = asSchema19("network.xyo.block.rejection", true);
+var BlockRejectionFieldsZod = z53.object({
+  block: HydratedBlockZod,
+  errors: z53.array(RejectionErrorZod),
+  rejector: z53.string()
+});
+var BlockRejectionZod = z53.extend(
+  PayloadZodOfSchema3(BlockRejectionSchema),
+  BlockRejectionFieldsZod.shape
+);
+var isBlockRejection = isPayloadOfSchemaType7(BlockRejectionSchema);
+var asBlockRejection = AsObjectFactory19.create(isBlockRejection);
+
+// src/modules/protocol-model/rejection/TransactionRejectionPayload.ts
+import { AsObjectFactory as AsObjectFactory20 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema20,
+  isPayloadOfSchemaType as isPayloadOfSchemaType8,
+  PayloadZodOfSchema as PayloadZodOfSchema4
+} from "@xyo-network/sdk";
+import { z as z54 } from "zod/mini";
+var TransactionRejectionSchema = asSchema20("network.xyo.transaction.rejection", true);
+var TransactionRejectionFieldsZod = z54.object({
+  errors: z54.array(RejectionErrorZod),
+  rejector: z54.string(),
+  transaction: HydratedTransactionZod
+});
+var TransactionRejectionZod = z54.extend(
+  PayloadZodOfSchema4(TransactionRejectionSchema),
+  TransactionRejectionFieldsZod.shape
+);
+var isTransactionRejection = isPayloadOfSchemaType8(TransactionRejectionSchema);
+var asTransactionRejection = AsObjectFactory20.create(isTransactionRejection);
+export {
+  AccountBalanceConfigZod,
+  AccountBalanceHistoryItemZod,
+  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,
+  BlockRejectionFieldsZod,
+  BlockRejectionSchema,
+  BlockRejectionZod,
+  BlockScriptsZod,
+  BlockStartZod,
+  BridgeDestinationObservationFieldsZod,
+  BridgeDestinationObservationSchema,
+  BridgeDetailsDestinationFieldsZod,
+  BridgeDetailsFieldsZod,
+  BridgeDetailsSourceFieldsZod,
+  BridgeIntentFieldsZod,
+  BridgeIntentSchema,
+  BridgeSourceObservationFieldsZod,
+  BridgeSourceObservationSchema,
+  CachesZod,
+  CachingContextZod,
+  CaveatTypesZod,
+  CaveatsZod,
+  ChainContextReadZod,
+  ChainContextWriteZod,
+  ChainContextZod,
+  ChainIdZod,
+  ChainQualificationZod,
+  ChainQualifiedConfigZod,
+  ChainQualifiedHeadConfigZod,
+  ChainQualifiedRangeConfigZod,
+  ChainQualifiedZod,
+  ChainStakeIntentSchema,
+  ChainZod,
+  CountZod,
+  DefaultProviderMoniker,
+  ELEVATE_OPCODE,
+  ETH_BLOCK_NUMBER_ZERO,
+  EpochTimeFieldsZod,
+  EthBlockNumberZod,
+  EthBlockNumberishZod,
+  EthBlockRangeZod,
+  EthBlockRangeishZod,
+  EthereumTimeFieldsZod,
+  ExchangeOutcomeFieldsZod,
+  ExchangeOutcomeSchema,
+  ExchangeTermsFieldsZod,
+  ExchangeTermsSchema,
+  ExtendChainQualifiedConfigZod,
+  FemtoXL1,
+  FemtoXL1MaxValue,
+  HashSchema,
+  HeadContextBaseZod,
+  HeadContextZod,
+  HydratedBlockWithHashMetaZod,
+  HydratedBlockWithStorageMetaZod,
+  HydratedBlockZod,
+  HydratedTransactionWithHashMetaZod,
+  HydratedTransactionWithStorageMetaZod,
+  HydratedTransactionZod,
+  InscriptionFieldsZod,
+  InscriptionSchema,
+  InvokerPermissionZod,
+  JsonToArrayBufferZod,
+  JsonToAttoZod,
+  JsonToStakeZod,
+  LocalSequenceFromStringZod,
+  LocalSequenceToStringZod,
+  LoggerZod,
+  MeterProviderZod,
+  MicroXL1,
+  MicroXL1MaxValue,
+  MilliXL1,
+  MilliXL1MaxValue,
+  NanoXL1,
+  NanoXL1MaxValue,
+  NumberishZod,
+  OrdinalTransferFieldsZod,
+  OrdinalTransferSchema,
+  PartySecretRevealFieldsZod,
+  PartySecretRevealSchema,
+  PermissionRequestZod,
+  PermissionZod,
+  PicoXL1,
+  PicoXL1MaxValue,
+  QualifiedSequenceFromStringZod,
+  QualifiedSequenceToStringZod,
+  RangeZod,
+  RejectionErrorZod,
+  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,
+  SyncStepSummaryMetadataZod,
+  SyncStepSummaryStatusZod,
+  SyncStepSummaryZod,
+  TickerZod,
+  TimeBudgetLimitZod,
+  TimeConfigZod,
+  TimeDomainZod,
+  TimeDurationsZod,
+  TimeFieldsZod,
+  TimePayloadZod,
+  TimeSchema,
+  TokenAmountZod,
+  TokenDeployFieldsZod,
+  TokenDeploySchema,
+  TokenMintFieldsZod,
+  TokenMintSchema,
+  TokenTransferFieldsZod,
+  TokenTransferSchema,
+  TracerProviderZod,
+  TransactionBoundWitnessFieldsZod,
+  TransactionBoundWitnessIdentityFields,
+  TransactionBoundWitnessWithHashMetaZod,
+  TransactionBoundWitnessWithStorageMetaZod,
+  TransactionBoundWitnessZod,
+  TransactionFeesBigIntToJsonZod,
+  TransactionFeesBigIntZod,
+  TransactionFeesHexZod,
+  TransactionFeesJsonToBigIntZod,
+  TransactionFeesZod,
+  TransactionGasCosts,
+  TransactionRejectionFieldsZod,
+  TransactionRejectionSchema,
+  TransactionRejectionZod,
+  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,
+  asBlockRejection,
+  asBridgeDestinationObservation,
+  asBridgeIntent,
+  asBridgeSourceObservation,
+  asChainId,
+  asChainStakeIntent,
+  asEthBlockNumber,
+  asEthBlockRange,
+  asExchangeOutcome,
+  asExchangeTerms,
+  asExecutable,
+  asFemtoXL1,
+  asHashPayload,
+  asHashPayloadWithStorageMeta,
+  asHydratedBlock,
+  asHydratedBlockWithHashMeta,
+  asHydratedBlockWithStorageMeta,
+  asHydratedTransaction,
+  asHydratedTransactionWithHashMeta,
+  asHydratedTransactionWithStorageMeta,
+  asInscription,
+  asMicroXL1,
+  asMilliXL1,
+  asNanoXL1,
+  asOrdinalTransfer,
+  asPartySecretReveal,
+  asPicoXL1,
+  asProviderMoniker,
+  asRange,
+  asSignedBlockBoundWitness,
+  asSignedBlockBoundWitnessWithHashMeta,
+  asSignedBlockBoundWitnessWithStorageMeta,
+  asSignedHydratedBlock,
+  asSignedHydratedBlockToJson,
+  asSignedHydratedBlockWithHashMeta,
+  asSignedHydratedBlockWithStorageMeta,
+  asSignedHydratedTransaction,
+  asSignedHydratedTransactionWithHashMeta,
+  asSignedHydratedTransactionWithStorageMeta,
+  asSignedTransactionBoundWitness,
+  asSignedTransactionBoundWitnessWithHashMeta,
+  asSignedTransactionBoundWitnessWithStorageMeta,
+  asSingleTimeConfig,
+  asStepComplete,
+  asStepIdentity,
+  asStepIdentityPayload,
+  asSyncStepSummary,
+  asSyncStepSummaryMetadata,
+  asSyncStepSummaryStatus,
+  asTimeConfig,
+  asTimeDurations,
+  asTimePayload,
+  asTimePayloadWithStorageMeta,
+  asTokenDeploy,
+  asTokenMint,
+  asTokenTransfer,
+  asTransactionBoundWitness,
+  asTransactionBoundWitnessWithHashMeta,
+  asTransactionBoundWitnessWithStorageMeta,
+  asTransactionFeesBigInt,
+  asTransactionFeesHex,
+  asTransactionRejection,
+  asTransfer,
+  asUnsignedBlockBoundWitness,
+  asUnsignedHydratedTransaction,
+  asUnsignedHydratedTransactionWithHashMeta,
+  asUnsignedHydratedTransactionWithStorageMeta,
+  asUnsignedTransactionBoundWitness,
+  asUnsignedTransactionBoundWitnessWithHashMeta,
+  asUnsignedTransactionBoundWitnessWithStorageMeta,
+  asValidStep,
+  asXL1,
+  asXL1BlockNumber,
+  asXL1BlockRange,
+  defaultRewardRatio,
+  defaultTransactionFees,
+  fromBlockNumberKey,
+  fromEthBlockNumberKey,
+  fromXL1BlockNumberKey,
+  hasFrom,
+  isAccountBalanceConfig,
+  isAllowedBlockPayload,
+  isAllowedBlockPayloadSchema,
+  isAllowedBlockPayloadWithHashMeta,
+  isAttoXL1,
+  isBlockBoundWitness,
+  isBlockBoundWitnessWithHashMeta,
+  isBlockBoundWitnessWithStorageMeta,
+  isBlockNumberPayload,
+  isBlockNumberPayloadWithSources,
+  isBlockRate,
+  isBlockRejection,
+  isBridgeDestinationObservation,
+  isBridgeIntent,
+  isBridgeSourceObservation,
+  isChainId,
+  isChainQualification,
+  isChainQualifiedConfig,
+  isChainQualifiedHeadConfig,
+  isChainQualifiedRangeConfig,
+  isChainStakeIntent,
+  isChainStakeIntentWithStorageMeta,
+  isExchangeOutcome,
+  isExchangeTerms,
+  isExecutable,
+  isFemtoXL1,
+  isHashPayload,
+  isHydratedBlock,
+  isHydratedBlockWithHashMeta,
+  isHydratedBlockWithStorageMeta,
+  isHydratedTransaction,
+  isHydratedTransactionWithHashMeta,
+  isHydratedTransactionWithStorageMeta,
+  isInscription,
+  isMicroXL1,
+  isMilliXL1,
+  isNanoXL1,
+  isOrdinalTransfer,
+  isPartySecretReveal,
+  isPicoXL1,
+  isRange,
+  isSafeEpoch,
+  isSignedBlockBoundWitness,
+  isSignedBlockBoundWitnessWithHashMeta,
+  isSignedBlockBoundWitnessWithStorageMeta,
+  isSignedHydratedBlock,
+  isSignedHydratedBlockToJson,
+  isSignedHydratedBlockWithHashMeta,
+  isSignedHydratedBlockWithStorageMeta,
+  isSignedHydratedTransaction,
+  isSignedHydratedTransactionWithHashMeta,
+  isSignedHydratedTransactionWithStorageMeta,
+  isSignedTransactionBoundWitness,
+  isSignedTransactionBoundWitnessWithHashMeta,
+  isSignedTransactionBoundWitnessWithStorageMeta,
+  isSingleTimeConfig,
+  isStepComplete,
+  isStepIdentityPayload,
+  isSyncStepSummary,
+  isSyncStepSummaryMetadata,
+  isSyncStepSummaryStatus,
+  isTimeConfig,
+  isTimeDurations,
+  isTimePayload,
+  isTokenDeploy,
+  isTokenMint,
+  isTokenTransfer,
+  isTransactionBoundWitness,
+  isTransactionBoundWitnessWithHashMeta,
+  isTransactionBoundWitnessWithStorageMeta,
+  isTransactionFeesBigInt,
+  isTransactionFeesHex,
+  isTransactionRejection,
+  isTransfer,
+  isUnsignedBlockBoundWitness,
+  isUnsignedHydratedTransaction,
+  isUnsignedHydratedTransactionWithHashMeta,
+  isUnsignedHydratedTransactionWithStorageMeta,
+  isUnsignedTransactionBoundWitness,
+  isUnsignedTransactionBoundWitnessWithHashMeta,
+  isUnsignedTransactionBoundWitnessWithStorageMeta,
+  isValidStep,
+  isXL1,
+  minTransactionFees,
+  stepSize,
+  toAttoXL1,
+  toBlockBoundWitness,
+  toBlockBoundWitnessWithHashMeta,
+  toBlockBoundWitnessWithStorageMeta,
+  toBlockNumber,
+  toBlockNumberKey,
+  toBlockRange,
+  toBlockRate,
+  toChainId,
+  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,
+  toSyncStepSummary,
+  toSyncStepSummaryMetadata,
+  toSyncStepSummaryStatus,
+  toTimeConfig,
+  toTimeDurations,
+  toTransactionBoundWitness,
+  toTransactionBoundWitnessWithHashMeta,
+  toTransactionBoundWitnessWithStorageMeta,
+  toTransactionFeesBigInt,
+  toTransactionFeesHex,
+  toUnsignedBlockBoundWitness,
+  toUnsignedHydratedTransaction,
+  toUnsignedHydratedTransactionWithHashMeta,
+  toUnsignedHydratedTransactionWithStorageMeta,
+  toUnsignedTransactionBoundWitness,
+  toUnsignedTransactionBoundWitnessWithHashMeta,
+  toUnsignedTransactionBoundWitnessWithStorageMeta,
+  toXL1,
+  toXL1BlockNumber,
+  toXL1BlockNumberKey,
+  toXL1BlockRange
+};
+//# sourceMappingURL=protocol-model.mjs.map