@fastxyz/cli 1.0.1 → 1.0.3

package/dist/chunk-DITXH2ZY.js

@@ -0,0 +1,2476 @@
+#!/usr/bin/env node
+import {
+  AppConfig
+} from "./chunk-UZZ2O26Y.js";
+import {
+  DatabaseService,
+  DefaultNetworkError,
+  FileIOError,
+  InvalidNetworkConfigError,
+  NetworkExistsError,
+  NetworkNotFoundError,
+  NoDefaultNetworkError,
+  ReservedNameError,
+  customNetworks,
+  metadata
+} from "./chunk-T7HRTMD7.js";
+
+// src/services/storage/network.ts
+import { readFileSync } from "fs";
+import { eq } from "drizzle-orm";
+import { Effect, Schema as Schema20 } from "effect";
+
+// src/schemas/networks.ts
+import { Schema as Schema19 } from "effect";
+
+// ../../packages/fast-schema/dist/index.js
+import { Schema as Schema6 } from "effect";
+import { bech32m } from "bech32";
+import { ParseResult, Schema } from "effect";
+import { Schema as Schema2 } from "effect";
+import { Schema as Schema3, String as Str } from "effect";
+import { Either, ParseResult as ParseResult2, Schema as Schema4 } from "effect";
+import { Schema as Schema5 } from "effect";
+import { Schema as Schema7 } from "effect";
+import { Schema as Schema8 } from "effect";
+import { Schema as Schema9 } from "effect";
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.3/node_modules/@mysten/bcs/dist/uleb.mjs
+function ulebEncode(num) {
+  let bigNum = BigInt(num);
+  const arr = [];
+  let len = 0;
+  if (bigNum === 0n) return [0];
+  while (bigNum > 0) {
+    arr[len] = Number(bigNum & 127n);
+    bigNum >>= 7n;
+    if (bigNum > 0n) arr[len] |= 128;
+    len += 1;
+  }
+  return arr;
+}
+function ulebDecode(arr) {
+  let total = 0n;
+  let shift = 0n;
+  let len = 0;
+  while (true) {
+    if (len >= arr.length) throw new Error("ULEB decode error: buffer overflow");
+    const byte = arr[len];
+    len += 1;
+    total += BigInt(byte & 127) << shift;
+    if ((byte & 128) === 0) break;
+    shift += 7n;
+  }
+  if (total > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("ULEB decode error: value exceeds MAX_SAFE_INTEGER");
+  return {
+    value: Number(total),
+    length: len
+  };
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.3/node_modules/@mysten/bcs/dist/reader.mjs
+var BcsReader = class {
+  /**
+  * @param {Uint8Array} data Data to use as a buffer.
+  */
+  constructor(data) {
+    this.bytePosition = 0;
+    this.dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  /**
+  * Shift current cursor position by `bytes`.
+  *
+  * @param {Number} bytes Number of bytes to
+  * @returns {this} Self for possible chaining.
+  */
+  shift(bytes) {
+    this.bytePosition += bytes;
+    return this;
+  }
+  /**
+  * Read U8 value from the buffer and shift cursor by 1.
+  * @returns
+  */
+  read8() {
+    const value = this.dataView.getUint8(this.bytePosition);
+    this.shift(1);
+    return value;
+  }
+  /**
+  * Read U16 value from the buffer and shift cursor by 2.
+  * @returns
+  */
+  read16() {
+    const value = this.dataView.getUint16(this.bytePosition, true);
+    this.shift(2);
+    return value;
+  }
+  /**
+  * Read U32 value from the buffer and shift cursor by 4.
+  * @returns
+  */
+  read32() {
+    const value = this.dataView.getUint32(this.bytePosition, true);
+    this.shift(4);
+    return value;
+  }
+  /**
+  * Read U64 value from the buffer and shift cursor by 8.
+  * @returns
+  */
+  read64() {
+    const value1 = this.read32();
+    const result = this.read32().toString(16) + value1.toString(16).padStart(8, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+  * Read U128 value from the buffer and shift cursor by 16.
+  */
+  read128() {
+    const value1 = BigInt(this.read64());
+    const result = BigInt(this.read64()).toString(16) + value1.toString(16).padStart(16, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+  * Read U128 value from the buffer and shift cursor by 32.
+  * @returns
+  */
+  read256() {
+    const value1 = BigInt(this.read128());
+    const result = BigInt(this.read128()).toString(16) + value1.toString(16).padStart(32, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+  * Read `num` number of bytes from the buffer and shift cursor by `num`.
+  * @param num Number of bytes to read.
+  */
+  readBytes(num) {
+    const start = this.bytePosition + this.dataView.byteOffset;
+    const value = new Uint8Array(this.dataView.buffer, start, num);
+    this.shift(num);
+    return value;
+  }
+  /**
+  * Read ULEB value - an integer of varying size. Used for enum indexes and
+  * vector lengths.
+  * @returns {Number} The ULEB value.
+  */
+  readULEB() {
+    const start = this.bytePosition + this.dataView.byteOffset;
+    const { value, length } = ulebDecode(new Uint8Array(this.dataView.buffer, start));
+    this.shift(length);
+    return value;
+  }
+  /**
+  * Read a BCS vector: read a length and then apply function `cb` X times
+  * where X is the length of the vector, defined as ULEB in BCS bytes.
+  * @param cb Callback to process elements of vector.
+  * @returns {Array<Any>} Array of the resulting values, returned by callback.
+  */
+  readVec(cb) {
+    const length = this.readULEB();
+    const result = [];
+    for (let i = 0; i < length; i++) result.push(cb(this, i, length));
+    return result;
+  }
+};
+
+// ../../node_modules/.pnpm/@scure+base@2.0.0/node_modules/@scure/base/index.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+// @__NO_SIDE_EFFECTS__
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber(d);
+    if (d < 0 || d >= from)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos; i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+    res.push(0);
+  return res.reverse();
+}
+// @__NO_SIDE_EFFECTS__
+function radix(num) {
+  anumber(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join(""));
+var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+
+// ../../node_modules/.pnpm/@mysten+utils@0.3.1/node_modules/@mysten/utils/dist/b58.mjs
+var toBase58 = (buffer) => base58.encode(buffer);
+var fromBase58 = (str) => base58.decode(str);
+
+// ../../node_modules/.pnpm/@mysten+utils@0.3.1/node_modules/@mysten/utils/dist/b64.mjs
+function fromBase64(base64String) {
+  return Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));
+}
+var CHUNK_SIZE = 8192;
+function toBase64(bytes) {
+  if (bytes.length < CHUNK_SIZE) return btoa(String.fromCharCode(...bytes));
+  let output = "";
+  for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.slice(i, i + CHUNK_SIZE);
+    output += String.fromCharCode(...chunk);
+  }
+  return btoa(output);
+}
+
+// ../../node_modules/.pnpm/@mysten+utils@0.3.1/node_modules/@mysten/utils/dist/hex.mjs
+function fromHex(hexStr) {
+  const normalized = hexStr.startsWith("0x") ? hexStr.slice(2) : hexStr;
+  const padded = normalized.length % 2 === 0 ? normalized : `0${normalized}`;
+  const intArr = padded.match(/[0-9a-fA-F]{2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
+  if (intArr.length !== padded.length / 2) throw new Error(`Invalid hex string ${hexStr}`);
+  return Uint8Array.from(intArr);
+}
+function toHex(bytes) {
+  return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.3/node_modules/@mysten/bcs/dist/utils.mjs
+function encodeStr(data, encoding) {
+  switch (encoding) {
+    case "base58":
+      return toBase58(data);
+    case "base64":
+      return toBase64(data);
+    case "hex":
+      return toHex(data);
+    default:
+      throw new Error("Unsupported encoding, supported values are: base64, hex");
+  }
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.3/node_modules/@mysten/bcs/dist/writer.mjs
+var BcsWriter = class {
+  constructor({ initialSize = 1024, maxSize = Infinity, allocateSize = 1024 } = {}) {
+    this.bytePosition = 0;
+    this.size = initialSize;
+    this.maxSize = maxSize;
+    this.allocateSize = allocateSize;
+    this.dataView = new DataView(new ArrayBuffer(initialSize));
+  }
+  ensureSizeOrGrow(bytes) {
+    const requiredSize = this.bytePosition + bytes;
+    if (requiredSize > this.size) {
+      const nextSize = Math.min(this.maxSize, Math.max(this.size + requiredSize, this.size + this.allocateSize));
+      if (requiredSize > nextSize) throw new Error(`Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${requiredSize}`);
+      this.size = nextSize;
+      const nextBuffer = new ArrayBuffer(this.size);
+      new Uint8Array(nextBuffer).set(new Uint8Array(this.dataView.buffer));
+      this.dataView = new DataView(nextBuffer);
+    }
+  }
+  /**
+  * Shift current cursor position by `bytes`.
+  *
+  * @param {Number} bytes Number of bytes to
+  * @returns {this} Self for possible chaining.
+  */
+  shift(bytes) {
+    this.bytePosition += bytes;
+    return this;
+  }
+  /**
+  * Write a U8 value into a buffer and shift cursor position by 1.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  write8(value) {
+    this.ensureSizeOrGrow(1);
+    this.dataView.setUint8(this.bytePosition, Number(value));
+    return this.shift(1);
+  }
+  /**
+  * Write a U8 value into a buffer and shift cursor position by 1.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  writeBytes(bytes) {
+    this.ensureSizeOrGrow(bytes.length);
+    for (let i = 0; i < bytes.length; i++) this.dataView.setUint8(this.bytePosition + i, bytes[i]);
+    return this.shift(bytes.length);
+  }
+  /**
+  * Write a U16 value into a buffer and shift cursor position by 2.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  write16(value) {
+    this.ensureSizeOrGrow(2);
+    this.dataView.setUint16(this.bytePosition, Number(value), true);
+    return this.shift(2);
+  }
+  /**
+  * Write a U32 value into a buffer and shift cursor position by 4.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  write32(value) {
+    this.ensureSizeOrGrow(4);
+    this.dataView.setUint32(this.bytePosition, Number(value), true);
+    return this.shift(4);
+  }
+  /**
+  * Write a U64 value into a buffer and shift cursor position by 8.
+  * @param {bigint} value Value to write.
+  * @returns {this}
+  */
+  write64(value) {
+    toLittleEndian(BigInt(value), 8).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+  * Write a U128 value into a buffer and shift cursor position by 16.
+  *
+  * @param {bigint} value Value to write.
+  * @returns {this}
+  */
+  write128(value) {
+    toLittleEndian(BigInt(value), 16).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+  * Write a U256 value into a buffer and shift cursor position by 16.
+  *
+  * @param {bigint} value Value to write.
+  * @returns {this}
+  */
+  write256(value) {
+    toLittleEndian(BigInt(value), 32).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+  * Write a ULEB value into a buffer and shift cursor position by number of bytes
+  * written.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  writeULEB(value) {
+    ulebEncode(value).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+  * Write a vector into a buffer by first writing the vector length and then calling
+  * a callback on each passed value.
+  *
+  * @param {Array<Any>} vector Array of elements to write.
+  * @param {WriteVecCb} cb Callback to call on each element of the vector.
+  * @returns {this}
+  */
+  writeVec(vector2, cb) {
+    this.writeULEB(vector2.length);
+    Array.from(vector2).forEach((el, i) => cb(this, el, i, vector2.length));
+    return this;
+  }
+  /**
+  * Adds support for iterations over the object.
+  * @returns {Uint8Array}
+  */
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.bytePosition; i++) yield this.dataView.getUint8(i);
+    return this.toBytes();
+  }
+  /**
+  * Get underlying buffer taking only value bytes (in case initial buffer size was bigger).
+  * @returns {Uint8Array} Resulting bcs.
+  */
+  toBytes() {
+    return new Uint8Array(this.dataView.buffer.slice(0, this.bytePosition));
+  }
+  /**
+  * Represent data as 'hex' or 'base64'
+  * @param encoding Encoding to use: 'base64' or 'hex'
+  */
+  toString(encoding) {
+    return encodeStr(this.toBytes(), encoding);
+  }
+};
+function toLittleEndian(bigint, size) {
+  const result = new Uint8Array(size);
+  let i = 0;
+  while (bigint > 0) {
+    result[i] = Number(bigint % BigInt(256));
+    bigint = bigint / BigInt(256);
+    i += 1;
+  }
+  return result;
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.3/node_modules/@mysten/bcs/dist/bcs-type.mjs
+var BcsType = class BcsType2 {
+  #write;
+  #serialize;
+  constructor(options) {
+    this.name = options.name;
+    this.read = options.read;
+    this.serializedSize = options.serializedSize ?? (() => null);
+    this.#write = options.write;
+    this.#serialize = options.serialize ?? ((value, options$1) => {
+      const writer = new BcsWriter({
+        initialSize: this.serializedSize(value) ?? void 0,
+        ...options$1
+      });
+      this.#write(value, writer);
+      return writer.toBytes();
+    });
+    this.validate = options.validate ?? (() => {
+    });
+  }
+  write(value, writer) {
+    this.validate(value);
+    this.#write(value, writer);
+  }
+  serialize(value, options) {
+    this.validate(value);
+    return new SerializedBcs(this, this.#serialize(value, options));
+  }
+  parse(bytes) {
+    const reader = new BcsReader(bytes);
+    return this.read(reader);
+  }
+  fromHex(hex) {
+    return this.parse(fromHex(hex));
+  }
+  fromBase58(b64) {
+    return this.parse(fromBase58(b64));
+  }
+  fromBase64(b64) {
+    return this.parse(fromBase64(b64));
+  }
+  transform({ name, input, output, validate }) {
+    return new BcsType2({
+      name: name ?? this.name,
+      read: (reader) => output ? output(this.read(reader)) : this.read(reader),
+      write: (value, writer) => this.#write(input ? input(value) : value, writer),
+      serializedSize: (value) => this.serializedSize(input ? input(value) : value),
+      serialize: (value, options) => this.#serialize(input ? input(value) : value, options),
+      validate: (value) => {
+        validate?.(value);
+        this.validate(input ? input(value) : value);
+      }
+    });
+  }
+};
+var SERIALIZED_BCS_BRAND = /* @__PURE__ */ Symbol.for("@mysten/serialized-bcs");
+var SerializedBcs = class {
+  #schema;
+  #bytes;
+  get [SERIALIZED_BCS_BRAND]() {
+    return true;
+  }
+  constructor(schema, bytes) {
+    this.#schema = schema;
+    this.#bytes = bytes;
+  }
+  toBytes() {
+    return this.#bytes;
+  }
+  toHex() {
+    return toHex(this.#bytes);
+  }
+  toBase64() {
+    return toBase64(this.#bytes);
+  }
+  toBase58() {
+    return toBase58(this.#bytes);
+  }
+  parse() {
+    return this.#schema.parse(this.#bytes);
+  }
+};
+function fixedSizeBcsType({ size, ...options }) {
+  return new BcsType({
+    ...options,
+    serializedSize: () => size
+  });
+}
+function uIntBcsType({ readMethod, writeMethod, ...options }) {
+  return fixedSizeBcsType({
+    ...options,
+    read: (reader) => reader[readMethod](),
+    write: (value, writer) => writer[writeMethod](value),
+    validate: (value) => {
+      if (value < 0 || value > options.maxValue) throw new TypeError(`Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`);
+      options.validate?.(value);
+    }
+  });
+}
+function bigUIntBcsType({ readMethod, writeMethod, ...options }) {
+  return fixedSizeBcsType({
+    ...options,
+    read: (reader) => reader[readMethod](),
+    write: (value, writer) => writer[writeMethod](BigInt(value)),
+    validate: (val) => {
+      const value = BigInt(val);
+      if (value < 0 || value > options.maxValue) throw new TypeError(`Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`);
+      options.validate?.(value);
+    }
+  });
+}
+function dynamicSizeBcsType({ serialize, ...options }) {
+  const type = new BcsType({
+    ...options,
+    serialize,
+    write: (value, writer) => {
+      for (const byte of type.serialize(value).toBytes()) writer.write8(byte);
+    }
+  });
+  return type;
+}
+function stringLikeBcsType({ toBytes, fromBytes, ...options }) {
+  return new BcsType({
+    ...options,
+    read: (reader) => {
+      const length = reader.readULEB();
+      return fromBytes(reader.readBytes(length));
+    },
+    write: (hex, writer) => {
+      const bytes = toBytes(hex);
+      writer.writeULEB(bytes.length);
+      for (let i = 0; i < bytes.length; i++) writer.write8(bytes[i]);
+    },
+    serialize: (value) => {
+      const bytes = toBytes(value);
+      const size = ulebEncode(bytes.length);
+      const result = new Uint8Array(size.length + bytes.length);
+      result.set(size, 0);
+      result.set(bytes, size.length);
+      return result;
+    },
+    validate: (value) => {
+      if (typeof value !== "string") throw new TypeError(`Invalid ${options.name} value: ${value}. Expected string`);
+      options.validate?.(value);
+    }
+  });
+}
+function lazyBcsType(cb) {
+  let lazyType = null;
+  function getType() {
+    if (!lazyType) lazyType = cb();
+    return lazyType;
+  }
+  return new BcsType({
+    name: "lazy",
+    read: (data) => getType().read(data),
+    serializedSize: (value) => getType().serializedSize(value),
+    write: (value, writer) => getType().write(value, writer),
+    serialize: (value, options) => getType().serialize(value, options).toBytes()
+  });
+}
+var BcsStruct = class extends BcsType {
+  constructor({ name, fields, ...options }) {
+    const canonicalOrder = Object.entries(fields);
+    super({
+      name,
+      serializedSize: (values) => {
+        let total = 0;
+        for (const [field, type] of canonicalOrder) {
+          const size = type.serializedSize(values[field]);
+          if (size == null) return null;
+          total += size;
+        }
+        return total;
+      },
+      read: (reader) => {
+        const result = {};
+        for (const [field, type] of canonicalOrder) result[field] = type.read(reader);
+        return result;
+      },
+      write: (value, writer) => {
+        for (const [field, type] of canonicalOrder) type.write(value[field], writer);
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "object" || value == null) throw new TypeError(`Expected object, found ${typeof value}`);
+      }
+    });
+  }
+};
+var BcsEnum = class extends BcsType {
+  constructor({ fields, ...options }) {
+    const canonicalOrder = Object.entries(fields);
+    super({
+      read: (reader) => {
+        const index = reader.readULEB();
+        const enumEntry = canonicalOrder[index];
+        if (!enumEntry) throw new TypeError(`Unknown value ${index} for enum ${options.name}`);
+        const [kind, type] = enumEntry;
+        return {
+          [kind]: type?.read(reader) ?? true,
+          $kind: kind
+        };
+      },
+      write: (value, writer) => {
+        const [name, val] = Object.entries(value).filter(([name$1]) => Object.hasOwn(fields, name$1))[0];
+        for (let i = 0; i < canonicalOrder.length; i++) {
+          const [optionName, optionType] = canonicalOrder[i];
+          if (optionName === name) {
+            writer.writeULEB(i);
+            optionType?.write(val, writer);
+            return;
+          }
+        }
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "object" || value == null) throw new TypeError(`Expected object, found ${typeof value}`);
+        const keys = Object.keys(value).filter((k) => value[k] !== void 0 && Object.hasOwn(fields, k));
+        if (keys.length !== 1) throw new TypeError(`Expected object with one key, but found ${keys.length} for type ${options.name}}`);
+        const [variant] = keys;
+        if (!Object.hasOwn(fields, variant)) throw new TypeError(`Invalid enum variant ${variant}`);
+      }
+    });
+  }
+};
+var BcsTuple = class extends BcsType {
+  constructor({ fields, name, ...options }) {
+    super({
+      name: name ?? `(${fields.map((t) => t.name).join(", ")})`,
+      serializedSize: (values) => {
+        let total = 0;
+        for (let i = 0; i < fields.length; i++) {
+          const size = fields[i].serializedSize(values[i]);
+          if (size == null) return null;
+          total += size;
+        }
+        return total;
+      },
+      read: (reader) => {
+        const result = [];
+        for (const field of fields) result.push(field.read(reader));
+        return result;
+      },
+      write: (value, writer) => {
+        for (let i = 0; i < fields.length; i++) fields[i].write(value[i], writer);
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (!Array.isArray(value)) throw new TypeError(`Expected array, found ${typeof value}`);
+        if (value.length !== fields.length) throw new TypeError(`Expected array of length ${fields.length}, found ${value.length}`);
+      }
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.3/node_modules/@mysten/bcs/dist/bcs.mjs
+function fixedArray(size, type, options) {
+  return new BcsType({
+    read: (reader) => {
+      const result = new Array(size);
+      for (let i = 0; i < size; i++) result[i] = type.read(reader);
+      return result;
+    },
+    write: (value, writer) => {
+      for (const item of value) type.write(item, writer);
+    },
+    ...options,
+    name: options?.name ?? `${type.name}[${size}]`,
+    validate: (value) => {
+      options?.validate?.(value);
+      if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+      if (value.length !== size) throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+    }
+  });
+}
+function option(type) {
+  return bcs.enum(`Option<${type.name}>`, {
+    None: null,
+    Some: type
+  }).transform({
+    input: (value) => {
+      if (value == null) return { None: true };
+      return { Some: value };
+    },
+    output: (value) => {
+      if (value.$kind === "Some") return value.Some;
+      return null;
+    }
+  });
+}
+function vector(type, options) {
+  return new BcsType({
+    read: (reader) => {
+      const length = reader.readULEB();
+      const result = new Array(length);
+      for (let i = 0; i < length; i++) result[i] = type.read(reader);
+      return result;
+    },
+    write: (value, writer) => {
+      writer.writeULEB(value.length);
+      for (const item of value) type.write(item, writer);
+    },
+    ...options,
+    name: options?.name ?? `vector<${type.name}>`,
+    validate: (value) => {
+      options?.validate?.(value);
+      if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+    }
+  });
+}
+function compareBcsBytes(a, b) {
+  for (let i = 0; i < Math.min(a.length, b.length); i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return a.length - b.length;
+}
+function map(keyType, valueType) {
+  return new BcsType({
+    name: `Map<${keyType.name}, ${valueType.name}>`,
+    read: (reader) => {
+      const length = reader.readULEB();
+      const result = /* @__PURE__ */ new Map();
+      for (let i = 0; i < length; i++) result.set(keyType.read(reader), valueType.read(reader));
+      return result;
+    },
+    write: (value, writer) => {
+      const entries = [...value.entries()].map(([key, val]) => [keyType.serialize(key).toBytes(), val]);
+      entries.sort(([a], [b]) => compareBcsBytes(a, b));
+      writer.writeULEB(entries.length);
+      for (const [keyBytes, val] of entries) {
+        writer.writeBytes(keyBytes);
+        valueType.write(val, writer);
+      }
+    }
+  });
+}
+var bcs = {
+  u8(options) {
+    return uIntBcsType({
+      readMethod: "read8",
+      writeMethod: "write8",
+      size: 1,
+      maxValue: 2 ** 8 - 1,
+      ...options,
+      name: options?.name ?? "u8"
+    });
+  },
+  u16(options) {
+    return uIntBcsType({
+      readMethod: "read16",
+      writeMethod: "write16",
+      size: 2,
+      maxValue: 2 ** 16 - 1,
+      ...options,
+      name: options?.name ?? "u16"
+    });
+  },
+  u32(options) {
+    return uIntBcsType({
+      readMethod: "read32",
+      writeMethod: "write32",
+      size: 4,
+      maxValue: 2 ** 32 - 1,
+      ...options,
+      name: options?.name ?? "u32"
+    });
+  },
+  u64(options) {
+    return bigUIntBcsType({
+      readMethod: "read64",
+      writeMethod: "write64",
+      size: 8,
+      maxValue: 2n ** 64n - 1n,
+      ...options,
+      name: options?.name ?? "u64"
+    });
+  },
+  u128(options) {
+    return bigUIntBcsType({
+      readMethod: "read128",
+      writeMethod: "write128",
+      size: 16,
+      maxValue: 2n ** 128n - 1n,
+      ...options,
+      name: options?.name ?? "u128"
+    });
+  },
+  u256(options) {
+    return bigUIntBcsType({
+      readMethod: "read256",
+      writeMethod: "write256",
+      size: 32,
+      maxValue: 2n ** 256n - 1n,
+      ...options,
+      name: options?.name ?? "u256"
+    });
+  },
+  bool(options) {
+    return fixedSizeBcsType({
+      size: 1,
+      read: (reader) => reader.read8() === 1,
+      write: (value, writer) => writer.write8(value ? 1 : 0),
+      ...options,
+      name: options?.name ?? "bool",
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "boolean") throw new TypeError(`Expected boolean, found ${typeof value}`);
+      }
+    });
+  },
+  uleb128(options) {
+    return dynamicSizeBcsType({
+      read: (reader) => reader.readULEB(),
+      serialize: (value) => {
+        return Uint8Array.from(ulebEncode(value));
+      },
+      ...options,
+      name: options?.name ?? "uleb128"
+    });
+  },
+  bytes(size, options) {
+    return fixedSizeBcsType({
+      size,
+      read: (reader) => reader.readBytes(size),
+      write: (value, writer) => {
+        writer.writeBytes(new Uint8Array(value));
+      },
+      ...options,
+      name: options?.name ?? `bytes[${size}]`,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+        if (value.length !== size) throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+      }
+    });
+  },
+  byteVector(options) {
+    return new BcsType({
+      read: (reader) => {
+        const length = reader.readULEB();
+        return reader.readBytes(length);
+      },
+      write: (value, writer) => {
+        const array = new Uint8Array(value);
+        writer.writeULEB(array.length);
+        writer.writeBytes(array);
+      },
+      ...options,
+      name: options?.name ?? "vector<u8>",
+      serializedSize: (value) => {
+        const length = "length" in value ? value.length : null;
+        return length == null ? null : ulebEncode(length).length + length;
+      },
+      validate: (value) => {
+        options?.validate?.(value);
+        if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+      }
+    });
+  },
+  string(options) {
+    return stringLikeBcsType({
+      toBytes: (value) => new TextEncoder().encode(value),
+      fromBytes: (bytes) => new TextDecoder().decode(bytes),
+      ...options,
+      name: options?.name ?? "string"
+    });
+  },
+  fixedArray,
+  option,
+  vector,
+  tuple(fields, options) {
+    return new BcsTuple({
+      fields,
+      ...options
+    });
+  },
+  struct(name, fields, options) {
+    return new BcsStruct({
+      name,
+      fields,
+      ...options
+    });
+  },
+  enum(name, fields, options) {
+    return new BcsEnum({
+      name,
+      fields,
+      ...options
+    });
+  },
+  map,
+  lazy(cb) {
+    return lazyBcsType(cb);
+  }
+};
+
+// ../../packages/fast-schema/dist/index.js
+import { Schema as Schema10 } from "effect";
+import { Schema as Schema13 } from "effect";
+import { Schema as Schema12 } from "effect";
+import { Schema as Schema11 } from "effect";
+import { Schema as Schema14 } from "effect";
+import { Schema as Schema15 } from "effect";
+import { Schema as Schema16 } from "effect";
+import { Schema as Schema17 } from "effect";
+import { Schema as Schema18 } from "effect";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var Uint8ArrayFromNumberArray = Schema.transform(Schema.Array(Schema.Number), Schema.Uint8ArrayFromSelf, {
+  strict: true,
+  decode: (arr) => new Uint8Array(arr),
+  encode: (buf) => Array.from(buf)
+});
+var Uint8ArrayFromBase64 = Schema.Uint8ArrayFromBase64;
+var Uint8ArrayFromHex = Schema.Uint8ArrayFromHex;
+var Strip0xHex = Schema.transform(Schema.String, Schema.String, {
+  strict: true,
+  decode: (s) => s.startsWith("0x") || s.startsWith("0X") ? s.slice(2) : s,
+  encode: (s) => s
+});
+var Uint8ArrayFromHexOptional0x = Schema.compose(Strip0xHex, Uint8ArrayFromHex);
+var Uint8ArrayFromBech32m = (hrp) => Schema.transformOrFail(Schema.String, Schema.Uint8ArrayFromSelf, {
+  strict: true,
+  decode: (encoded, _options, ast) => {
+    let result;
+    try {
+      result = bech32m.decode(encoded);
+    } catch (e) {
+      const error = e instanceof Error ? e.message : String(e);
+      const message = `Failed to decode bech32m: ${error}`;
+      const failure = new ParseResult.Type(ast, encoded, message);
+      return ParseResult.fail(failure);
+    }
+    const prefix = result.prefix;
+    const words = result.words;
+    if (prefix !== hrp) {
+      const message = `Expected bech32m prefix "${hrp}", got "${prefix}"`;
+      const failure = new ParseResult.Type(ast, encoded, message);
+      return ParseResult.fail(failure);
+    }
+    const array = new Uint8Array(bech32m.fromWords(words));
+    return ParseResult.succeed(array);
+  },
+  encode: (data, _options, ast) => {
+    let words;
+    try {
+      words = bech32m.toWords(data);
+    } catch (e) {
+      const error = e instanceof Error ? e.message : String(e);
+      const message = `Failed to encode bech32m: ${error}`;
+      const inner = new ParseResult.Type(ast, data, message);
+      const failure = new ParseResult.Transformation(ast, data, "Transformation", inner);
+      return ParseResult.fail(failure);
+    }
+    return ParseResult.succeed(bech32m.encode(hrp, words));
+  }
+});
+var FixedUint8Array = (n) => Schema.Uint8ArrayFromSelf.pipe(
+  Schema.filter((a) => a.length === n, {
+    message: () => `Expected exactly ${n} bytes`
+  }),
+  Schema.brand(`Uint8Array${n}`)
+);
+var FixedUint8ArrayFromNumberArray = (n) => Schema.compose(Uint8ArrayFromNumberArray, FixedUint8Array(n));
+var FixedUint8ArrayFromHex = (n) => Schema.compose(Uint8ArrayFromHex, FixedUint8Array(n));
+var FixedUint8ArrayFromHexOptional0x = (n) => Schema.compose(Uint8ArrayFromHexOptional0x, FixedUint8Array(n));
+var DecimalBigInt = Schema2.BigInt;
+var HexBigInt = Schema2.transform(Schema2.String, Schema2.BigIntFromSelf, {
+  strict: true,
+  decode: (s) => {
+    const sign = s[0] === "-" ? -1n : 1n;
+    const digits = s[0] === "-" ? s.slice(1) : s;
+    if (digits.length === 0 || !/^[0-9a-fA-F]+$/.test(digits)) {
+      throw new Error(`Invalid hex string: "${s}"`);
+    }
+    return sign * BigInt(`0x${digits}`);
+  },
+  encode: (n) => n.toString(16)
+});
+var DecimalNumber = Schema2.NumberFromString;
+var HexNumber = Schema2.transform(Schema2.String, Schema2.Number, {
+  strict: true,
+  decode: (s) => {
+    if (s.length === 0 || !/^[0-9a-fA-F]+$/.test(s)) {
+      throw new Error(`Invalid hex string: "${s}"`);
+    }
+    return Number(`0x${s}`);
+  },
+  encode: (n) => n.toString(16)
+});
+var BigIntFromNumberOrStringOrSelf = Schema2.transform(
+  Schema2.Union(Schema2.Number, Schema2.BigIntFromSelf, Schema2.String),
+  Schema2.BigIntFromSelf,
+  {
+    strict: true,
+    decode: (n) => typeof n === "bigint" ? n : BigInt(n),
+    encode: (n) => n
+  }
+);
+var UintNumber = (bits) => Schema2.Number.pipe(Schema2.int(), Schema2.between(0, 2 ** bits - 1), Schema2.brand(`Uint${bits}`));
+var IntNumber = (bits) => Schema2.Number.pipe(Schema2.int(), Schema2.between(-(2 ** (bits - 1)), 2 ** (bits - 1) - 1), Schema2.brand(`Int${bits}`));
+var UintBigInt = (bits) => Schema2.BigIntFromSelf.pipe(Schema2.betweenBigInt(0n, 2n ** BigInt(bits) - 1n), Schema2.brand(`Uint${bits}`));
+var IntBigInt = (bits) => Schema2.BigIntFromSelf.pipe(Schema2.betweenBigInt(-(2n ** BigInt(bits - 1)), 2n ** BigInt(bits - 1) - 1n), Schema2.brand(`Int${bits}`));
+var HexUintBigInt = (bits) => Schema2.compose(HexBigInt, UintBigInt(bits));
+var HexIntBigInt = (bits) => Schema2.compose(HexBigInt, IntBigInt(bits));
+var DecimalUintBigInt = (bits) => Schema2.compose(DecimalBigInt, UintBigInt(bits));
+var DecimalIntBigInt = (bits) => Schema2.compose(DecimalBigInt, IntBigInt(bits));
+var UintBigIntFromNumberOrStringOrSelf = (bits) => Schema2.compose(BigIntFromNumberOrStringOrSelf, UintBigInt(bits));
+var IntBigIntFromNumberOrStringOrSelf = (bits) => Schema2.compose(BigIntFromNumberOrStringOrSelf, IntBigInt(bits));
+var Uint8Array32 = FixedUint8Array(32);
+var Uint8Array64 = FixedUint8Array(64);
+var Uint8Array32FromNumberArray = FixedUint8ArrayFromNumberArray(32);
+var Uint8Array32FromHex = FixedUint8ArrayFromHex(32);
+var Uint8Array32FromHex0x = FixedUint8ArrayFromHexOptional0x(32);
+var Uint8Array64FromNumberArray = FixedUint8ArrayFromNumberArray(64);
+var Uint8Array64FromHex0x = FixedUint8ArrayFromHexOptional0x(64);
+var Uint8Array64FromHex = FixedUint8ArrayFromHex(64);
+var Uint8 = UintNumber(8);
+var Uint16 = UintNumber(16);
+var Uint32 = UintNumber(32);
+var Int32 = IntNumber(32);
+var Uint64 = UintBigInt(64);
+var Int64 = IntBigInt(64);
+var Uint128 = UintBigInt(128);
+var Uint256 = UintBigInt(256);
+var Int320 = IntBigInt(320);
+var HexUint64 = HexUintBigInt(64);
+var HexUint256 = HexUintBigInt(256);
+var HexInt320 = HexIntBigInt(320);
+var DecimalUint64 = DecimalUintBigInt(64);
+var DecimalUint256 = DecimalUintBigInt(256);
+var DecimalInt320 = DecimalIntBigInt(320);
+var Uint64FromNumberOrStringOrSelf = UintBigIntFromNumberOrStringOrSelf(64);
+var Uint256FromNumberOrStringOrSelf = UintBigIntFromNumberOrStringOrSelf(256);
+var Int320FromNumberOrStringOrSelf = IntBigIntFromNumberOrStringOrSelf(320);
+var CamelCaseStruct = (fields) => {
+  const structFields = {};
+  for (const key of Object.keys(fields)) {
+    const schema = fields[key];
+    const camelKey = Str.snakeToCamel(key);
+    if (camelKey !== key) {
+      structFields[camelKey] = Schema3.propertySignature(schema).pipe(Schema3.fromKey(key));
+    } else {
+      structFields[camelKey] = schema;
+    }
+  }
+  return Schema3.Struct(structFields);
+};
+var KeyedVariantSchema = Schema4.Union(
+  Schema4.Record({ key: Schema4.String, value: Schema4.Unknown }),
+  Schema4.String
+);
+var TypedVariantSchema = Schema4.Struct({
+  type: Schema4.String,
+  value: Schema4.optional(Schema4.Unknown)
+});
+var TypedVariant = (variants, options) => {
+  const bcsMode = options?.unitEncoding === "bcs";
+  const fail = (ast, actual, message) => ParseResult2.fail(new ParseResult2.Type(ast, actual, message));
+  return Schema4.transformOrFail(KeyedVariantSchema, TypedVariantSchema, {
+    strict: false,
+    decode: (kv, _options, ast) => {
+      if (typeof kv === "string") {
+        if (!(kv in variants)) return fail(ast, kv, `Unknown variant "${kv}"`);
+        if (variants[kv] !== null)
+          return fail(ast, kv, `Variant "${kv}" expects data`);
+        return ParseResult2.succeed({ type: kv });
+      }
+      const keys = Object.keys(kv);
+      if (keys.length !== 1) {
+        return fail(ast, kv, `Expected exactly one key, got ${keys.length}`);
+      }
+      const type = keys[0];
+      if (!(type in variants))
+        return fail(ast, kv, `Unknown variant "${type}"`);
+      const schema = variants[type];
+      if (schema === null || schema === void 0) {
+        return ParseResult2.succeed({ type });
+      }
+      const decoded = ParseResult2.decodeUnknownEither(
+        schema
+      )(kv[type]);
+      if (Either.isLeft(decoded)) return ParseResult2.fail(decoded.left);
+      return ParseResult2.succeed({ type, value: decoded.right });
+    },
+    encode: (tv, _options, ast) => {
+      const { type, value } = tv;
+      if (!(type in variants))
+        return fail(ast, tv, `Unknown variant "${type}"`);
+      const schema = variants[type];
+      if (schema === null || schema === void 0) {
+        return ParseResult2.succeed(bcsMode ? { [type]: [] } : type);
+      }
+      const encoded = ParseResult2.encodeUnknownEither(
+        schema
+      )(value);
+      if (Either.isLeft(encoded)) return ParseResult2.fail(encoded.left);
+      return ParseResult2.succeed({ [type]: encoded.right });
+    }
+  });
+};
+var Amount = Uint256.pipe(Schema5.brand("Amount"));
+var Balance = Int320.pipe(Schema5.brand("Balance"));
+var Nonce = Uint64.pipe(Schema5.brand("Nonce"));
+var Quorum = Uint64.pipe(Schema5.brand("Quorum"));
+var NetworkId = Schema5.Literal("fast:localnet", "fast:devnet", "fast:testnet", "fast:mainnet");
+var TransactionVersion = Schema5.Literal("Release20260319", "Release20260407");
+var SupportedTransactionVersions = TransactionVersion.literals;
+var LatestTransactionVersion = "Release20260407";
+var Address = Uint8Array32.pipe(Schema5.brand("Address"));
+var Signature = Uint8Array64.pipe(Schema5.brand("Signature"));
+var TokenId = Uint8Array32.pipe(Schema5.brand("TokenId"));
+var StateKey = Uint8Array32.pipe(Schema5.brand("StateKey"));
+var State = Uint8Array32.pipe(Schema5.brand("State"));
+var ClaimData = Schema5.Uint8ArrayFromSelf.pipe(Schema5.brand("ClaimData"));
+var UserData = Schema5.NullOr(Uint8Array32.pipe(Schema5.brand("UserData")));
+var AmountFromBcs = Uint256FromNumberOrStringOrSelf.pipe(Schema6.brand("Amount"));
+var BalanceFromBcs = Int320FromNumberOrStringOrSelf.pipe(Schema6.brand("Balance"));
+var NonceFromBcs = Uint64FromNumberOrStringOrSelf.pipe(Schema6.brand("Nonce"));
+var QuorumFromBcs = Uint64FromNumberOrStringOrSelf.pipe(Schema6.brand("Quorum"));
+var NetworkIdFromBcs = NetworkId;
+var AddressFromBcs = Uint8Array32FromNumberArray.pipe(Schema6.brand("Address"));
+var SignatureFromBcs = Uint8Array64FromNumberArray.pipe(Schema6.brand("Signature"));
+var TokenIdFromBcs = Uint8Array32FromNumberArray.pipe(Schema6.brand("TokenId"));
+var StateKeyFromBcs = Uint8Array32FromNumberArray.pipe(Schema6.brand("StateKey"));
+var StateFromBcs = Uint8Array32FromNumberArray.pipe(Schema6.brand("State"));
+var ClaimDataFromBcs = Uint8ArrayFromNumberArray.pipe(Schema6.brand("ClaimData"));
+var UserDataFromBcs = Schema6.NullOr(Uint8Array32FromNumberArray.pipe(Schema6.brand("UserData")));
+var AmountFromInput = Schema7.Union(
+  Uint256FromNumberOrStringOrSelf,
+  HexUint256,
+  DecimalUint256
+).pipe(Schema7.brand("Amount"));
+var BalanceFromInput = Schema7.Union(
+  Int320FromNumberOrStringOrSelf,
+  HexInt320,
+  DecimalInt320
+).pipe(Schema7.brand("Balance"));
+var NonceFromInput = Uint64FromNumberOrStringOrSelf.pipe(
+  Schema7.brand("Nonce")
+);
+var QuorumFromInput = Uint64FromNumberOrStringOrSelf.pipe(
+  Schema7.brand("Quorum")
+);
+var NetworkIdFromInput = NetworkId;
+var AddressFromInput = Schema7.Union(
+  Uint8Array32,
+  Uint8Array32FromNumberArray,
+  Uint8Array32FromHex0x,
+  Schema7.compose(Uint8ArrayFromBech32m("fast"), Uint8Array32)
+).pipe(Schema7.brand("Address"));
+var SignatureFromInput = Schema7.Union(
+  Uint8Array64,
+  Uint8Array64FromNumberArray,
+  Uint8Array64FromHex0x
+).pipe(Schema7.brand("Signature"));
+var TokenIdFromInput = Schema7.Union(
+  Uint8Array32,
+  Uint8Array32FromNumberArray,
+  Uint8Array32FromHex0x
+).pipe(Schema7.brand("TokenId"));
+var StateKeyFromInput = Schema7.Union(
+  Uint8Array32,
+  Uint8Array32FromNumberArray,
+  Uint8Array32FromHex0x
+).pipe(Schema7.brand("StateKey"));
+var StateFromInput = Schema7.Union(
+  Uint8Array32,
+  Uint8Array32FromNumberArray,
+  Uint8Array32FromHex0x
+).pipe(Schema7.brand("State"));
+var ClaimDataFromInput = Schema7.Union(
+  Schema7.Uint8ArrayFromSelf,
+  Uint8ArrayFromNumberArray,
+  Uint8ArrayFromHexOptional0x
+).pipe(Schema7.brand("ClaimData"));
+var UserDataFromInput = Schema7.NullOr(
+  Schema7.Union(
+    Uint8Array32,
+    Uint8Array32FromNumberArray,
+    Uint8Array32FromHex0x
+  ).pipe(Schema7.brand("UserData"))
+);
+var AmountFromRest = DecimalUint256.pipe(Schema8.brand("Amount"));
+var BalanceFromRest = DecimalInt320.pipe(Schema8.brand("Balance"));
+var NonceFromRest = Uint64FromNumberOrStringOrSelf.pipe(Schema8.brand("Nonce"));
+var QuorumFromRest = Uint64FromNumberOrStringOrSelf.pipe(Schema8.brand("Quorum"));
+var NetworkIdFromRest = NetworkId;
+var AddressFromRest = Schema8.compose(Uint8ArrayFromBech32m("fast"), Uint8Array32).pipe(Schema8.brand("Address"));
+var SignatureFromRest = Uint8Array64FromHex.pipe(Schema8.brand("Signature"));
+var TokenIdFromRest = Uint8Array32FromHex.pipe(Schema8.brand("TokenId"));
+var StateKeyFromRest = Uint8Array32FromHex.pipe(Schema8.brand("StateKey"));
+var StateFromRest = Uint8Array32FromHex.pipe(Schema8.brand("State"));
+var ClaimDataFromRest = Schema8.Uint8ArrayFromHex.pipe(Schema8.brand("ClaimData"));
+var UserDataFromRest = Schema8.NullOr(Uint8Array32FromHex.pipe(Schema8.brand("UserData")));
+var AmountFromRpc = HexUint256.pipe(Schema9.brand("Amount"));
+var BalanceFromRpc = HexInt320.pipe(Schema9.brand("Balance"));
+var NonceFromRpc = Uint64FromNumberOrStringOrSelf.pipe(Schema9.brand("Nonce"));
+var QuorumFromRpc = Uint64FromNumberOrStringOrSelf.pipe(Schema9.brand("Quorum"));
+var NetworkIdFromRpc = NetworkId;
+var AddressFromRpc = Uint8Array32FromNumberArray.pipe(Schema9.brand("Address"));
+var SignatureFromRpc = Uint8Array64FromNumberArray.pipe(Schema9.brand("Signature"));
+var TokenIdFromRpc = Uint8Array32FromNumberArray.pipe(Schema9.brand("TokenId"));
+var StateKeyFromRpc = Uint8Array32FromNumberArray.pipe(Schema9.brand("StateKey"));
+var StateFromRpc = Uint8Array32FromNumberArray.pipe(Schema9.brand("State"));
+var ClaimDataFromRpc = Uint8ArrayFromNumberArray.pipe(Schema9.brand("ClaimData"));
+var UserDataFromRpc = Schema9.NullOr(Uint8Array32FromNumberArray.pipe(Schema9.brand("UserData")));
+var bcs_layout_exports = {};
+__export(bcs_layout_exports, {
+  AddressChange: () => AddressChange,
+  Amount: () => Amount2,
+  Burn: () => Burn,
+  ClaimData: () => ClaimData2,
+  ClaimType: () => ClaimType,
+  CommitteeChange: () => CommitteeChange,
+  CommitteeConfig: () => CommitteeConfig,
+  Escrow: () => Escrow,
+  EscrowComplete: () => EscrowComplete,
+  EscrowCreateConfig: () => EscrowCreateConfig,
+  EscrowCreateJob: () => EscrowCreateJob,
+  EscrowReject: () => EscrowReject,
+  EscrowSubmit: () => EscrowSubmit,
+  ExternalClaim: () => ExternalClaim,
+  ExternalClaimBody: () => ExternalClaimBody,
+  FixedAmountOrBps: () => FixedAmountOrBps,
+  Mint: () => Mint,
+  MultiSig: () => MultiSig,
+  MultiSigConfig: () => MultiSigConfig,
+  Nonce: () => Nonce2,
+  Operation: () => Operation,
+  PublicKeyBytes: () => PublicKeyBytes,
+  Quorum: () => Quorum2,
+  Signature: () => Signature2,
+  SignatureOrMultiSig: () => SignatureOrMultiSig,
+  State: () => State2,
+  StateInitialization: () => StateInitialization,
+  StateKey: () => StateKey2,
+  StateReset: () => StateReset,
+  StateUpdate: () => StateUpdate,
+  TimestampNanos: () => TimestampNanos,
+  TokenCreation: () => TokenCreation,
+  TokenDecimals: () => TokenDecimals,
+  TokenId: () => TokenId2,
+  TokenManagement: () => TokenManagement,
+  TokenName: () => TokenName,
+  TokenTransfer: () => TokenTransfer,
+  Transaction20260319: () => Transaction20260319,
+  Transaction20260407: () => Transaction20260407,
+  UserData: () => UserData2,
+  ValidatorConfig: () => ValidatorConfig,
+  VerifierSig: () => VerifierSig,
+  VersionedTransaction: () => VersionedTransaction
+});
+var PublicKeyBytes = bcs.fixedArray(32, bcs.u8());
+var StateKey2 = bcs.fixedArray(32, bcs.u8());
+var Nonce2 = bcs.u64();
+var TimestampNanos = bcs.u128();
+var TokenId2 = bcs.fixedArray(32, bcs.u8());
+var TokenName = bcs.string();
+var TokenDecimals = bcs.u8();
+var Amount2 = bcs.u256();
+var UserData2 = bcs.option(bcs.fixedArray(32, bcs.u8()));
+var State2 = bcs.fixedArray(32, bcs.u8());
+var Quorum2 = bcs.u64();
+var ClaimData2 = bcs.vector(bcs.u8());
+var Signature2 = bcs.fixedArray(64, bcs.u8());
+var MultiSigConfig = bcs.struct("MultiSigConfig", {
+  authorized_signers: bcs.vector(PublicKeyBytes),
+  quorum: Quorum2,
+  nonce: Nonce2
+});
+var MultiSig = bcs.struct("MultiSig", {
+  config: MultiSigConfig,
+  signatures: bcs.vector(bcs.tuple([PublicKeyBytes, Signature2]))
+});
+var SignatureOrMultiSig = bcs.enum("SignatureOrMultiSig", {
+  Signature: Signature2,
+  MultiSig
+});
+var AddressChange = bcs.enum("AddressChange", {
+  Add: bcs.tuple([]),
+  Remove: bcs.tuple([])
+});
+var TokenTransfer = bcs.struct("TokenTransfer", {
+  token_id: TokenId2,
+  recipient: PublicKeyBytes,
+  amount: Amount2,
+  user_data: UserData2
+});
+var TokenCreation = bcs.struct("TokenCreation", {
+  token_name: TokenName,
+  decimals: TokenDecimals,
+  initial_amount: Amount2,
+  mints: bcs.vector(PublicKeyBytes),
+  user_data: UserData2
+});
+var TokenManagement = bcs.struct("TokenManagement", {
+  token_id: TokenId2,
+  update_id: Nonce2,
+  new_admin: bcs.option(PublicKeyBytes),
+  mints: bcs.vector(bcs.tuple([AddressChange, PublicKeyBytes])),
+  user_data: UserData2
+});
+var Mint = bcs.struct("Mint", {
+  token_id: TokenId2,
+  recipient: PublicKeyBytes,
+  amount: Amount2
+});
+var Burn = bcs.struct("Burn", {
+  token_id: TokenId2,
+  amount: Amount2
+});
+var StateInitialization = bcs.struct("StateInitialization", {
+  key: StateKey2,
+  initial_state: State2
+});
+var StateUpdate = bcs.struct("StateUpdate", {
+  key: StateKey2,
+  previous_state: State2,
+  next_state: State2,
+  compute_claim_tx_hash: bcs.fixedArray(32, bcs.u8()),
+  compute_claim_tx_timestamp: TimestampNanos
+});
+var StateReset = bcs.struct("StateReset", {
+  key: StateKey2,
+  reset_state: State2
+});
+var ExternalClaimBody = bcs.struct("ExternalClaimBody", {
+  verifier_committee: bcs.vector(PublicKeyBytes),
+  verifier_quorum: Quorum2,
+  claim_data: ClaimData2
+});
+var VerifierSig = bcs.struct("VerifierSig", {
+  verifier_addr: PublicKeyBytes,
+  sig: Signature2
+});
+var ExternalClaim = bcs.struct("ExternalClaim", {
+  claim: ExternalClaimBody,
+  signatures: bcs.vector(VerifierSig)
+});
+var ValidatorConfig = bcs.struct("ValidatorConfig", {
+  address: PublicKeyBytes,
+  host: bcs.string(),
+  rpc_port: bcs.u32()
+});
+var CommitteeConfig = bcs.struct("CommitteeConfig", {
+  validators: bcs.vector(ValidatorConfig)
+});
+var CommitteeChange = bcs.struct("CommitteeChange", {
+  new_committee: CommitteeConfig,
+  epoch: bcs.u32()
+});
+var FixedAmountOrBps = bcs.enum("FixedAmountOrBps", {
+  Fixed: Amount2,
+  Bps: bcs.u16()
+});
+var EscrowCreateConfig = bcs.struct("EscrowCreateConfig", {
+  token_id: TokenId2,
+  evaluator: PublicKeyBytes,
+  evaluation_fee: FixedAmountOrBps,
+  min_evaluator_fee: Amount2
+});
+var EscrowCreateJob = bcs.struct("EscrowCreateJob", {
+  config_id: bcs.fixedArray(32, bcs.u8()),
+  provider: PublicKeyBytes,
+  provider_fee: Amount2,
+  description: bcs.string()
+});
+var EscrowSubmit = bcs.struct("EscrowSubmit", {
+  job_id: bcs.fixedArray(32, bcs.u8()),
+  deliverable: bcs.fixedArray(32, bcs.u8())
+});
+var EscrowReject = bcs.struct("EscrowReject", {
+  job_id: bcs.fixedArray(32, bcs.u8())
+});
+var EscrowComplete = bcs.struct("EscrowComplete", {
+  job_id: bcs.fixedArray(32, bcs.u8())
+});
+var Escrow = bcs.enum("Escrow", {
+  CreateConfig: EscrowCreateConfig,
+  CreateJob: EscrowCreateJob,
+  Submit: EscrowSubmit,
+  Reject: EscrowReject,
+  Complete: EscrowComplete
+});
+var Operation = bcs.enum("Operation", {
+  TokenTransfer,
+  TokenCreation,
+  TokenManagement,
+  Mint,
+  Burn,
+  StateInitialization,
+  StateUpdate,
+  ExternalClaim,
+  StateReset,
+  JoinCommittee: ValidatorConfig,
+  LeaveCommittee: bcs.tuple([]),
+  ChangeCommittee: CommitteeChange,
+  Escrow
+});
+var ClaimType = bcs.enum("ClaimType", {
+  TokenTransfer,
+  TokenCreation,
+  TokenManagement,
+  Mint,
+  Burn,
+  StateInitialization,
+  StateUpdate,
+  ExternalClaim,
+  StateReset,
+  JoinCommittee: ValidatorConfig,
+  LeaveCommittee: bcs.tuple([]),
+  ChangeCommittee: CommitteeChange,
+  Escrow,
+  Batch: bcs.vector(Operation)
+});
+var Transaction20260319 = bcs.struct("Transaction", {
+  network_id: bcs.string(),
+  sender: PublicKeyBytes,
+  nonce: Nonce2,
+  timestamp_nanos: TimestampNanos,
+  claim: ClaimType,
+  archival: bcs.bool(),
+  fee_token: bcs.option(TokenId2)
+});
+var Transaction20260407 = bcs.struct("Transaction20260407", {
+  network_id: bcs.string(),
+  sender: PublicKeyBytes,
+  nonce: Nonce2,
+  timestamp_nanos: TimestampNanos,
+  claims: bcs.vector(Operation),
+  archival: bcs.bool(),
+  fee_token: bcs.option(TokenId2)
+});
+var VersionedTransaction = bcs.enum("VersionedTransaction", {
+  Release20260319: Transaction20260319,
+  Release20260407: Transaction20260407
+});
+var FastSetErrorData = TypedVariant({
+  UnexpectedNonce: CamelCaseStruct({
+    expected_nonce: BigIntFromNumberOrStringOrSelf
+  }),
+  InsufficientFunding: CamelCaseStruct({
+    current_balance: BigIntFromNumberOrStringOrSelf
+  }),
+  PreviousTransactionMustBeConfirmedFirst: CamelCaseStruct({
+    pending_confirmation: Schema10.Unknown
+  }),
+  InvalidSignature: Schema10.Struct({
+    error: Schema10.String
+  }),
+  MissingEarlierConfirmations: CamelCaseStruct({
+    current_nonce: BigIntFromNumberOrStringOrSelf
+  }),
+  CertificateTooYoung: CamelCaseStruct({
+    resend_after_nanos: BigIntFromNumberOrStringOrSelf
+  }),
+  NonSubmittableOperation: Schema10.Struct({
+    reason: Schema10.String
+  })
+});
+var JsonRpcError = TypedVariant({
+  FastSet: FastSetErrorData,
+  Generic: Schema10.String
+});
+var ProxyErrorData = TypedVariant({
+  GeneralError: Schema10.String,
+  FaucetDisabled: null,
+  RpcError: JsonRpcError,
+  FaucetThrottled: Schema10.Unknown,
+  FaucetTxnFailed: Schema10.Unknown,
+  FaucetThresholdExceeded: Schema10.Unknown,
+  VerifierSigsInvalid: Schema10.Unknown,
+  DatabaseError: Schema10.String,
+  TooManyCertificatesRequested: null,
+  UnexpectedNonce: CamelCaseStruct({
+    tx_nonce: BigIntFromNumberOrStringOrSelf,
+    expected_nonce: BigIntFromNumberOrStringOrSelf
+  }),
+  InvalidRequest: Schema10.String
+});
+var makeAddressChange = (options) => TypedVariant({ Add: null, Remove: null }, options);
+var AddressChange2 = makeAddressChange();
+var makeTokenTransfer = (p4) => CamelCaseStruct({
+  token_id: p4.TokenId,
+  recipient: p4.Address,
+  amount: p4.Amount,
+  user_data: p4.UserData
+});
+var makeTokenCreation = (p4) => CamelCaseStruct({
+  token_name: Schema11.String,
+  decimals: Schema11.Number,
+  initial_amount: p4.Amount,
+  mints: Schema11.Array(p4.Address),
+  user_data: p4.UserData
+});
+var makeTokenManagement = (p4, options) => CamelCaseStruct({
+  token_id: p4.TokenId,
+  update_id: p4.Nonce,
+  new_admin: Schema11.NullOr(p4.Address),
+  mints: Schema11.Array(Schema11.Tuple(makeAddressChange(options), p4.Address)),
+  user_data: p4.UserData
+});
+var makeMint = (p4) => CamelCaseStruct({
+  token_id: p4.TokenId,
+  recipient: p4.Address,
+  amount: p4.Amount
+});
+var makeBurn = (p4) => CamelCaseStruct({ token_id: p4.TokenId, amount: p4.Amount });
+var makeStateInitialization = (p4) => CamelCaseStruct({ key: p4.StateKey, initial_state: p4.State });
+var makeStateUpdate = (p4) => CamelCaseStruct({
+  key: p4.StateKey,
+  previous_state: p4.State,
+  next_state: p4.State,
+  compute_claim_tx_hash: p4.StateKey,
+  compute_claim_tx_timestamp: p4.BigInt
+});
+var makeStateReset = (p4) => CamelCaseStruct({ key: p4.StateKey, reset_state: p4.State });
+var makeExternalClaimBody = (p4) => CamelCaseStruct({
+  verifier_committee: Schema11.Array(p4.Address),
+  verifier_quorum: p4.Quorum,
+  claim_data: p4.ClaimData
+});
+var makeVerifierSig = (p4) => CamelCaseStruct({ verifier_addr: p4.Address, sig: p4.Signature });
+var makeExternalClaim = (p4) => Schema11.Struct({
+  claim: makeExternalClaimBody(p4),
+  signatures: Schema11.Array(makeVerifierSig(p4))
+});
+var makeValidatorConfig = (p4) => CamelCaseStruct({
+  address: p4.Address,
+  host: Schema11.String,
+  rpc_port: Schema11.Number
+});
+var makeCommitteeConfig = (p4) => Schema11.Struct({ validators: Schema11.Array(makeValidatorConfig(p4)) });
+var makeCommitteeChange = (p4) => CamelCaseStruct({
+  new_committee: makeCommitteeConfig(p4),
+  epoch: Schema11.Number
+});
+var makeFixedAmountOrBps = (p4, options) => TypedVariant({ Fixed: p4.Amount, Bps: Schema11.Number }, options);
+var makeEscrowCreateConfig = (p4, options) => CamelCaseStruct({
+  token_id: p4.TokenId,
+  evaluator: p4.Address,
+  evaluation_fee: makeFixedAmountOrBps(p4, options),
+  min_evaluator_fee: p4.Amount
+});
+var makeEscrowCreateJob = (p4) => CamelCaseStruct({
+  config_id: p4.TokenId,
+  provider: p4.Address,
+  provider_fee: p4.Amount,
+  description: Schema11.String
+});
+var makeEscrowSubmit = (p4) => CamelCaseStruct({ job_id: p4.TokenId, deliverable: p4.TokenId });
+var makeEscrowReject = (p4) => CamelCaseStruct({ job_id: p4.TokenId });
+var makeEscrowComplete = (p4) => CamelCaseStruct({ job_id: p4.TokenId });
+var makeEscrow = (p4, options) => TypedVariant(
+  {
+    CreateConfig: makeEscrowCreateConfig(p4, options),
+    CreateJob: makeEscrowCreateJob(p4),
+    Submit: makeEscrowSubmit(p4),
+    Reject: makeEscrowReject(p4),
+    Complete: makeEscrowComplete(p4)
+  },
+  options
+);
+var makeOperation = (p4, options) => TypedVariant(
+  {
+    TokenTransfer: makeTokenTransfer(p4),
+    TokenCreation: makeTokenCreation(p4),
+    TokenManagement: makeTokenManagement(p4, options),
+    Mint: makeMint(p4),
+    Burn: makeBurn(p4),
+    StateInitialization: makeStateInitialization(p4),
+    StateUpdate: makeStateUpdate(p4),
+    StateReset: makeStateReset(p4),
+    ExternalClaim: makeExternalClaim(p4),
+    JoinCommittee: makeValidatorConfig(p4),
+    LeaveCommittee: null,
+    ChangeCommittee: makeCommitteeChange(p4),
+    Escrow: makeEscrow(p4, options)
+  },
+  options
+);
+var makeClaimType = (p4, options) => TypedVariant(
+  {
+    TokenTransfer: makeTokenTransfer(p4),
+    TokenCreation: makeTokenCreation(p4),
+    TokenManagement: makeTokenManagement(p4, options),
+    Mint: makeMint(p4),
+    Burn: makeBurn(p4),
+    StateInitialization: makeStateInitialization(p4),
+    StateUpdate: makeStateUpdate(p4),
+    StateReset: makeStateReset(p4),
+    ExternalClaim: makeExternalClaim(p4),
+    JoinCommittee: makeValidatorConfig(p4),
+    LeaveCommittee: null,
+    ChangeCommittee: makeCommitteeChange(p4),
+    Escrow: makeEscrow(p4, options),
+    Batch: Schema11.Array(makeOperation(p4, options))
+  },
+  options
+);
+var makeTransactionRelease20260319 = (p4, options) => CamelCaseStruct({
+  network_id: p4.NetworkId,
+  sender: p4.Address,
+  nonce: p4.Nonce,
+  timestamp_nanos: p4.BigInt,
+  claim: makeClaimType(p4, options),
+  archival: Schema12.Boolean,
+  fee_token: Schema12.NullOr(p4.TokenId)
+});
+var makeTransactionRelease20260407 = (p4, options) => CamelCaseStruct({
+  network_id: p4.NetworkId,
+  sender: p4.Address,
+  nonce: p4.Nonce,
+  timestamp_nanos: p4.BigInt,
+  claims: Schema12.Array(makeOperation(p4, options)),
+  archival: Schema12.Boolean,
+  fee_token: Schema12.NullOr(p4.TokenId)
+});
+var makeTransaction = makeTransactionRelease20260407;
+var makeVersionedTransaction = (p4, options) => TypedVariant({
+  Release20260319: makeTransactionRelease20260319(p4, options),
+  Release20260407: makeTransactionRelease20260407(p4, options)
+});
+var makeMultiSigConfig = (p4) => CamelCaseStruct({ authorized_signers: Schema13.Array(p4.Address), quorum: p4.Quorum, nonce: p4.Nonce });
+var makeMultiSig = (p4) => Schema13.Struct({
+  config: makeMultiSigConfig(p4),
+  signatures: Schema13.Array(Schema13.Tuple(p4.Address, p4.Signature))
+});
+var makeSignatureOrMultiSig = (p4) => TypedVariant({
+  Signature: p4.Signature,
+  MultiSig: makeMultiSig(p4)
+});
+var makeTransactionEnvelope = (p4) => Schema13.Struct({
+  transaction: makeVersionedTransaction(p4),
+  signature: makeSignatureOrMultiSig(p4)
+});
+var makeValidatedTransaction = (p4) => Schema13.Struct({
+  value: makeTransactionEnvelope(p4),
+  validator: p4.Address,
+  signature: p4.Signature
+});
+var makeTransactionCertificate = (p4) => Schema13.Struct({
+  envelope: makeTransactionEnvelope(p4),
+  signatures: Schema13.Array(Schema13.Tuple(p4.Address, p4.Signature))
+});
+var makeNonceRange = (p4) => Schema14.Struct({ start: p4.Nonce, limit: Schema14.Number });
+var makePageRequest = (p4) => Schema14.Struct({ limit: Schema14.Number, token: Schema14.optional(p4.BigInt) });
+var makeTokenMetadata = (p4) => CamelCaseStruct({
+  update_id: p4.Nonce,
+  admin: p4.Address,
+  token_name: Schema14.String,
+  decimals: Schema14.Number,
+  total_supply: p4.Amount,
+  mints: Schema14.Array(p4.Address)
+});
+var makeAccountInfoResponse = (p4) => CamelCaseStruct({
+  sender: p4.Address,
+  balance: p4.Balance,
+  next_nonce: p4.Nonce,
+  pending_confirmation: Schema14.NullOr(makeValidatedTransaction(p4)),
+  requested_state: Schema14.Array(Schema14.Tuple(p4.StateKey, p4.State)),
+  requested_certificates: Schema14.NullOr(Schema14.Array(makeTransactionCertificate(p4))),
+  requested_validated_transaction: Schema14.NullOr(makeValidatedTransaction(p4)),
+  token_balance: Schema14.Array(Schema14.Tuple(p4.TokenId, p4.Balance))
+});
+var makeTokenInfoResponse = (p4) => CamelCaseStruct({
+  requested_token_metadata: Schema14.Array(Schema14.Tuple(p4.TokenId, Schema14.NullOr(makeTokenMetadata(p4))))
+});
+var makeSubmitTransactionResponse = (p4) => CamelCaseStruct({ validator: p4.Address, signature: p4.Signature, next_nonce: p4.Nonce, transaction_hash: p4.ClaimData });
+var makeConfirmTransactionResponse = (p4) => CamelCaseStruct({ token_ids: Schema14.Array(p4.TokenId) });
+var makeProxySubmitTransactionResult = (p4) => TypedVariant({
+  Success: makeTransactionCertificate(p4),
+  IncompleteVerifierSigs: null,
+  IncompleteMultiSig: null
+});
+var makeEscrowJobRecord = (p4) => CamelCaseStruct({
+  job_id: p4.TokenId,
+  config_id: p4.TokenId,
+  client: p4.Address,
+  provider: p4.Address,
+  evaluator: p4.Address,
+  token_id: p4.TokenId,
+  provider_fee: p4.Amount,
+  evaluator_fee: p4.Amount,
+  description: Schema14.String,
+  deliverable: Schema14.NullOr(p4.TokenId),
+  status: Schema14.String
+});
+var makeEscrowJobWithCerts = (p4) => Schema14.Struct({
+  job: makeEscrowJobRecord(p4),
+  certificates: Schema14.Array(makeTransactionCertificate(p4))
+});
+var makeSubmitTransactionParams = (p4) => makeTransactionEnvelope(p4);
+var makeFaucetDripParams = (p4) => CamelCaseStruct({
+  recipient: p4.Address,
+  amount: p4.Amount,
+  token_id: Schema15.NullOr(p4.TokenId)
+});
+var makeGetAccountInfoParams = (p4) => CamelCaseStruct({
+  address: p4.Address,
+  token_balances_filter: Schema15.NullOr(Schema15.Array(p4.TokenId)),
+  state_key_filter: Schema15.NullOr(Schema15.Array(p4.StateKey)),
+  certificate_by_nonce: Schema15.NullOr(Schema15.Struct({ start: p4.Nonce, limit: Schema15.Number }))
+});
+var makeGetPendingMultisigParams = (p4) => Schema15.Struct({ address: p4.Address });
+var makeGetTokenInfoParams = (p4) => CamelCaseStruct({ token_ids: Schema15.Array(p4.TokenId) });
+var makeGetTransactionCertificatesParams = (p4) => CamelCaseStruct({
+  address: p4.Address,
+  from_nonce: p4.Nonce,
+  limit: Schema15.Number
+});
+var FaucetDripInput = Schema15.Struct({
+  recipient: AddressFromInput,
+  amount: AmountFromInput,
+  tokenId: Schema15.NullOr(TokenIdFromInput)
+});
+var GetAccountInfoInput = Schema15.Struct({
+  address: AddressFromInput,
+  tokenBalancesFilter: Schema15.optionalWith(Schema15.NullOr(Schema15.Array(TokenIdFromInput)), { default: () => null }),
+  stateKeyFilter: Schema15.optionalWith(Schema15.NullOr(Schema15.Array(StateKeyFromInput)), { default: () => null }),
+  certificateByNonce: Schema15.optionalWith(
+    Schema15.NullOr(
+      Schema15.Struct({
+        start: NonceFromInput,
+        limit: Schema15.Number
+      })
+    ),
+    { default: () => null }
+  )
+});
+var GetPendingMultisigInput = Schema15.Struct({
+  address: AddressFromInput
+});
+var GetTokenInfoInput = Schema15.Struct({
+  tokenIds: Schema15.Array(TokenIdFromInput)
+});
+var GetTransactionCertificatesInput = Schema15.Struct({
+  address: AddressFromInput,
+  fromNonce: NonceFromInput,
+  limit: Schema15.Number
+});
+var GetEscrowJobInput = Schema15.Struct({
+  jobId: TokenIdFromInput,
+  certs: Schema15.optionalWith(Schema15.Boolean, { default: () => false })
+});
+var GetEscrowJobsInput = Schema15.Struct({
+  client: Schema15.optional(AddressFromInput),
+  provider: Schema15.optional(AddressFromInput),
+  evaluator: Schema15.optional(AddressFromInput),
+  status: Schema15.optional(Schema15.String),
+  certs: Schema15.optionalWith(Schema15.Boolean, { default: () => false })
+});
+var PrivateKeyFromInput = Schema16.Union(Uint8Array32, Uint8Array32FromHex0x, Uint8Array32FromNumberArray).pipe(Schema16.brand("PrivateKey"));
+var TokenTransferInput = Schema17.Struct({
+  tokenId: TokenIdFromInput,
+  recipient: AddressFromInput,
+  amount: AmountFromInput,
+  userData: UserDataFromInput
+});
+var TokenCreationInput = Schema17.Struct({
+  tokenName: Schema17.String,
+  decimals: Schema17.Number,
+  initialAmount: AmountFromInput,
+  mints: Schema17.Array(AddressFromInput),
+  userData: UserDataFromInput
+});
+var TokenManagementInput = Schema17.Struct({
+  tokenId: TokenIdFromInput,
+  updateId: NonceFromInput,
+  newAdmin: Schema17.NullOr(AddressFromInput),
+  mints: Schema17.Array(
+    Schema17.Tuple(Schema17.Union(Schema17.Struct({ type: Schema17.Literal("Add") }), Schema17.Struct({ type: Schema17.Literal("Remove") })), AddressFromInput)
+  ),
+  userData: UserDataFromInput
+});
+var MintInput = Schema17.Struct({
+  tokenId: TokenIdFromInput,
+  recipient: AddressFromInput,
+  amount: AmountFromInput
+});
+var BurnInput = Schema17.Struct({
+  tokenId: TokenIdFromInput,
+  amount: AmountFromInput
+});
+var StateInitializationInput = Schema17.Struct({
+  key: StateKeyFromInput,
+  initialState: StateFromInput
+});
+var StateUpdateInput = Schema17.Struct({
+  key: StateKeyFromInput,
+  previousState: StateFromInput,
+  nextState: StateFromInput,
+  computeClaimTxHash: StateKeyFromInput,
+  computeClaimTxTimestamp: BigIntFromNumberOrStringOrSelf
+});
+var StateResetInput = Schema17.Struct({
+  key: StateKeyFromInput,
+  resetState: StateFromInput
+});
+var ExternalClaimInput = Schema17.Struct({
+  claim: Schema17.Struct({
+    verifierCommittee: Schema17.Array(AddressFromInput),
+    verifierQuorum: QuorumFromInput,
+    claimData: ClaimDataFromInput
+  }),
+  signatures: Schema17.Array(
+    Schema17.Struct({
+      verifierAddr: AddressFromInput,
+      sig: SignatureFromInput
+    })
+  )
+});
+var ValidatorConfigInput = Schema17.Struct({
+  address: AddressFromInput,
+  host: Schema17.String,
+  rpcPort: Schema17.Number
+});
+var CommitteeChangeInput = Schema17.Struct({
+  newCommittee: Schema17.Struct({
+    validators: Schema17.Array(ValidatorConfigInput)
+  }),
+  epoch: Schema17.Number
+});
+var FixedAmountOrBpsInput = Schema17.Union(
+  Schema17.Struct({ type: Schema17.Literal("Fixed"), value: AmountFromInput }),
+  Schema17.Struct({ type: Schema17.Literal("Bps"), value: Schema17.Number })
+);
+var EscrowCreateConfigInput = Schema17.Struct({
+  tokenId: TokenIdFromInput,
+  evaluator: AddressFromInput,
+  evaluationFee: FixedAmountOrBpsInput,
+  minEvaluatorFee: AmountFromInput
+});
+var EscrowCreateJobInput = Schema17.Struct({
+  configId: TokenIdFromInput,
+  provider: AddressFromInput,
+  providerFee: AmountFromInput,
+  description: Schema17.String
+});
+var EscrowSubmitInput = Schema17.Struct({
+  jobId: TokenIdFromInput,
+  deliverable: TokenIdFromInput
+});
+var EscrowRejectInput = Schema17.Struct({
+  jobId: TokenIdFromInput
+});
+var EscrowCompleteInput = Schema17.Struct({
+  jobId: TokenIdFromInput
+});
+var EscrowInput = Schema17.Union(
+  Schema17.Struct({ type: Schema17.Literal("CreateConfig"), value: EscrowCreateConfigInput }),
+  Schema17.Struct({ type: Schema17.Literal("CreateJob"), value: EscrowCreateJobInput }),
+  Schema17.Struct({ type: Schema17.Literal("Submit"), value: EscrowSubmitInput }),
+  Schema17.Struct({ type: Schema17.Literal("Reject"), value: EscrowRejectInput }),
+  Schema17.Struct({ type: Schema17.Literal("Complete"), value: EscrowCompleteInput })
+);
+var OperationInput = Schema17.Union(
+  Schema17.Struct({
+    type: Schema17.Literal("TokenTransfer"),
+    value: TokenTransferInput
+  }),
+  Schema17.Struct({
+    type: Schema17.Literal("TokenCreation"),
+    value: TokenCreationInput
+  }),
+  Schema17.Struct({
+    type: Schema17.Literal("TokenManagement"),
+    value: TokenManagementInput
+  }),
+  Schema17.Struct({ type: Schema17.Literal("Mint"), value: MintInput }),
+  Schema17.Struct({ type: Schema17.Literal("Burn"), value: BurnInput }),
+  Schema17.Struct({
+    type: Schema17.Literal("StateInitialization"),
+    value: StateInitializationInput
+  }),
+  Schema17.Struct({
+    type: Schema17.Literal("StateUpdate"),
+    value: StateUpdateInput
+  }),
+  Schema17.Struct({ type: Schema17.Literal("StateReset"), value: StateResetInput }),
+  Schema17.Struct({
+    type: Schema17.Literal("ExternalClaim"),
+    value: ExternalClaimInput
+  }),
+  Schema17.Struct({
+    type: Schema17.Literal("JoinCommittee"),
+    value: ValidatorConfigInput
+  }),
+  Schema17.Struct({ type: Schema17.Literal("LeaveCommittee") }),
+  Schema17.Struct({
+    type: Schema17.Literal("ChangeCommittee"),
+    value: CommitteeChangeInput
+  }),
+  Schema17.Struct({
+    type: Schema17.Literal("Escrow"),
+    value: EscrowInput
+  })
+);
+var ClaimTypeInput = Schema17.Union(
+  ...OperationInput.members,
+  Schema17.Struct({
+    type: Schema17.Literal("Batch"),
+    value: Schema17.Array(OperationInput)
+  })
+);
+var TransactionRelease20260319Input = Schema17.Struct({
+  networkId: NetworkIdFromInput,
+  sender: AddressFromInput,
+  nonce: NonceFromInput,
+  timestampNanos: BigIntFromNumberOrStringOrSelf,
+  claim: ClaimTypeInput,
+  archival: Schema17.Boolean,
+  feeToken: Schema17.NullOr(TokenIdFromInput)
+});
+var TransactionRelease20260407Input = Schema17.Struct({
+  networkId: NetworkIdFromInput,
+  sender: AddressFromInput,
+  nonce: NonceFromInput,
+  timestampNanos: BigIntFromNumberOrStringOrSelf,
+  claims: Schema17.Array(OperationInput),
+  archival: Schema17.Boolean,
+  feeToken: Schema17.NullOr(TokenIdFromInput)
+});
+var TransactionVersionRegistry = {
+  Release20260319: {
+    wrapOperations(ops) {
+      if (ops.length === 0) {
+        throw new Error("Release20260319 transactions require at least one operation");
+      }
+      const claim = ops.length === 1 ? ops[0] : { type: "Batch", value: ops };
+      return { claim };
+    },
+    extractOperations(decoded) {
+      const claim = decoded.claim;
+      if (claim == null) return [];
+      if (typeof claim === "object" && !Array.isArray(claim)) {
+        const rec = claim;
+        if ("Batch" in rec && Array.isArray(rec.Batch)) {
+          return rec.Batch;
+        }
+        if (rec.type === "Batch" && Array.isArray(rec.value)) {
+          return rec.value;
+        }
+        return [claim];
+      }
+      return [];
+    },
+    inputSchema: TransactionRelease20260319Input
+  },
+  Release20260407: {
+    wrapOperations(ops) {
+      return { claims: ops };
+    },
+    extractOperations(decoded) {
+      return Array.isArray(decoded.claims) ? decoded.claims : [];
+    },
+    inputSchema: TransactionRelease20260407Input
+  }
+};
+function getTransactionVersionConfig(version) {
+  if (!(version in TransactionVersionRegistry)) {
+    throw new Error(`Unknown transaction version: ${version}`);
+  }
+  return TransactionVersionRegistry[version];
+}
+var RpcPalette = {
+  Amount: AmountFromRpc,
+  Balance: BalanceFromRpc,
+  Nonce: NonceFromRpc,
+  Quorum: QuorumFromRpc,
+  NetworkId: NetworkIdFromRpc,
+  Address: AddressFromRpc,
+  Signature: SignatureFromRpc,
+  TokenId: TokenIdFromRpc,
+  StateKey: StateKeyFromRpc,
+  State: StateFromRpc,
+  ClaimData: ClaimDataFromRpc,
+  UserData: UserDataFromRpc,
+  BigInt: BigIntFromNumberOrStringOrSelf
+};
+var RestPalette = {
+  Amount: AmountFromRest,
+  Balance: BalanceFromRest,
+  Nonce: NonceFromRest,
+  Quorum: QuorumFromRest,
+  NetworkId: NetworkIdFromRest,
+  Address: AddressFromRest,
+  Signature: SignatureFromRest,
+  TokenId: TokenIdFromRest,
+  StateKey: StateKeyFromRest,
+  State: StateFromRest,
+  ClaimData: ClaimDataFromRest,
+  UserData: UserDataFromRest,
+  BigInt: BigIntFromNumberOrStringOrSelf
+};
+var BcsPalette = {
+  Amount: AmountFromBcs,
+  Balance: BalanceFromBcs,
+  Nonce: NonceFromBcs,
+  Quorum: QuorumFromBcs,
+  NetworkId: NetworkIdFromBcs,
+  Address: AddressFromBcs,
+  Signature: SignatureFromBcs,
+  TokenId: TokenIdFromBcs,
+  StateKey: StateKeyFromBcs,
+  State: StateFromBcs,
+  ClaimData: ClaimDataFromBcs,
+  UserData: UserDataFromBcs,
+  BigInt: BigIntFromNumberOrStringOrSelf
+};
+var p = BcsPalette;
+var TokenTransferFromBcs = makeTokenTransfer(p);
+var TokenCreationFromBcs = makeTokenCreation(p);
+var TokenManagementFromBcs = makeTokenManagement(p);
+var MintFromBcs = makeMint(p);
+var BurnFromBcs = makeBurn(p);
+var StateInitializationFromBcs = makeStateInitialization(p);
+var StateUpdateFromBcs = makeStateUpdate(p);
+var StateResetFromBcs = makeStateReset(p);
+var ExternalClaimBodyFromBcs = makeExternalClaimBody(p);
+var VerifierSigFromBcs = makeVerifierSig(p);
+var ExternalClaimFromBcs = makeExternalClaim(p);
+var ValidatorConfigFromBcs = makeValidatorConfig(p);
+var CommitteeConfigFromBcs = makeCommitteeConfig(p);
+var CommitteeChangeFromBcs = makeCommitteeChange(p);
+var bcsOpts = { unitEncoding: "bcs" };
+var FixedAmountOrBpsFromBcs = makeFixedAmountOrBps(p, bcsOpts);
+var EscrowCreateConfigFromBcs = makeEscrowCreateConfig(p, bcsOpts);
+var EscrowCreateJobFromBcs = makeEscrowCreateJob(p);
+var EscrowSubmitFromBcs = makeEscrowSubmit(p);
+var EscrowRejectFromBcs = makeEscrowReject(p);
+var EscrowCompleteFromBcs = makeEscrowComplete(p);
+var EscrowFromBcs = makeEscrow(p, bcsOpts);
+var OperationFromBcs = makeOperation(p, bcsOpts);
+var ClaimTypeFromBcs = makeClaimType(p, bcsOpts);
+var TransactionRelease20260319FromBcs = makeTransactionRelease20260319(
+  p,
+  bcsOpts
+);
+var TransactionRelease20260407FromBcs = makeTransactionRelease20260407(
+  p,
+  bcsOpts
+);
+var TransactionFromBcs = makeTransaction(p, bcsOpts);
+var VersionedTransactionFromBcs = makeVersionedTransaction(p, bcsOpts);
+var MultiSigConfigFromBcs = makeMultiSigConfig(p);
+var MultiSigFromBcs = makeMultiSig(p);
+var SignatureOrMultiSigFromBcs = makeSignatureOrMultiSig(p);
+var TransactionEnvelopeFromBcs = makeTransactionEnvelope(p);
+var ValidatedTransactionFromBcs = makeValidatedTransaction(p);
+var TransactionCertificateFromBcs = makeTransactionCertificate(p);
+var NonceRangeFromBcs = makeNonceRange(p);
+var PageRequestFromBcs = makePageRequest(p);
+var TokenMetadataFromBcs = makeTokenMetadata(p);
+var AccountInfoResponseFromBcs = makeAccountInfoResponse(p);
+var TokenInfoResponseFromBcs = makeTokenInfoResponse(p);
+var SubmitTransactionResponseFromBcs = makeSubmitTransactionResponse(p);
+var ConfirmTransactionResponseFromBcs = makeConfirmTransactionResponse(p);
+var ProxySubmitTransactionResultFromBcs = makeProxySubmitTransactionResult(p);
+var EscrowJobRecordFromBcs = makeEscrowJobRecord(p);
+var EscrowJobWithCertsFromBcs = makeEscrowJobWithCerts(p);
+var p2 = RestPalette;
+var TokenTransferFromRest = makeTokenTransfer(p2);
+var TokenCreationFromRest = makeTokenCreation(p2);
+var TokenManagementFromRest = makeTokenManagement(p2);
+var MintFromRest = makeMint(p2);
+var BurnFromRest = makeBurn(p2);
+var StateInitializationFromRest = makeStateInitialization(p2);
+var StateUpdateFromRest = makeStateUpdate(p2);
+var StateResetFromRest = makeStateReset(p2);
+var ExternalClaimBodyFromRest = makeExternalClaimBody(p2);
+var VerifierSigFromRest = makeVerifierSig(p2);
+var ExternalClaimFromRest = makeExternalClaim(p2);
+var ValidatorConfigFromRest = makeValidatorConfig(p2);
+var CommitteeConfigFromRest = makeCommitteeConfig(p2);
+var CommitteeChangeFromRest = makeCommitteeChange(p2);
+var FixedAmountOrBpsFromRest = makeFixedAmountOrBps(p2);
+var EscrowCreateConfigFromRest = makeEscrowCreateConfig(p2);
+var EscrowCreateJobFromRest = makeEscrowCreateJob(p2);
+var EscrowSubmitFromRest = makeEscrowSubmit(p2);
+var EscrowRejectFromRest = makeEscrowReject(p2);
+var EscrowCompleteFromRest = makeEscrowComplete(p2);
+var EscrowFromRest = makeEscrow(p2);
+var OperationFromRest = makeOperation(p2);
+var ClaimTypeFromRest = makeClaimType(p2);
+var TransactionRelease20260319FromRest = makeTransactionRelease20260319(p2);
+var TransactionRelease20260407FromRest = makeTransactionRelease20260407(p2);
+var TransactionFromRest = makeTransaction(p2);
+var VersionedTransactionFromRest = makeVersionedTransaction(p2);
+var MultiSigConfigFromRest = makeMultiSigConfig(p2);
+var MultiSigFromRest = makeMultiSig(p2);
+var SignatureOrMultiSigFromRest = makeSignatureOrMultiSig(p2);
+var TransactionEnvelopeFromRest = makeTransactionEnvelope(p2);
+var ValidatedTransactionFromRest = makeValidatedTransaction(p2);
+var TransactionCertificateFromRest = makeTransactionCertificate(p2);
+var NonceRangeFromRest = makeNonceRange(p2);
+var PageRequestFromRest = makePageRequest(p2);
+var TokenMetadataFromRest = makeTokenMetadata(p2);
+var AccountInfoResponseFromRest = makeAccountInfoResponse(p2);
+var TokenInfoResponseFromRest = makeTokenInfoResponse(p2);
+var SubmitTransactionResponseFromRest = makeSubmitTransactionResponse(p2);
+var ConfirmTransactionResponseFromRest = makeConfirmTransactionResponse(p2);
+var ProxySubmitTransactionResultFromRest = makeProxySubmitTransactionResult(p2);
+var EscrowJobRecordFromRest = makeEscrowJobRecord(p2);
+var EscrowJobWithCertsFromRest = makeEscrowJobWithCerts(p2);
+var p3 = RpcPalette;
+var TokenTransferFromRpc = makeTokenTransfer(p3);
+var TokenCreationFromRpc = makeTokenCreation(p3);
+var TokenManagementFromRpc = makeTokenManagement(p3);
+var MintFromRpc = makeMint(p3);
+var BurnFromRpc = makeBurn(p3);
+var StateInitializationFromRpc = makeStateInitialization(p3);
+var StateUpdateFromRpc = makeStateUpdate(p3);
+var StateResetFromRpc = makeStateReset(p3);
+var ExternalClaimBodyFromRpc = makeExternalClaimBody(p3);
+var VerifierSigFromRpc = makeVerifierSig(p3);
+var ExternalClaimFromRpc = makeExternalClaim(p3);
+var ValidatorConfigFromRpc = makeValidatorConfig(p3);
+var CommitteeConfigFromRpc = makeCommitteeConfig(p3);
+var CommitteeChangeFromRpc = makeCommitteeChange(p3);
+var FixedAmountOrBpsFromRpc = makeFixedAmountOrBps(p3);
+var EscrowCreateConfigFromRpc = makeEscrowCreateConfig(p3);
+var EscrowCreateJobFromRpc = makeEscrowCreateJob(p3);
+var EscrowSubmitFromRpc = makeEscrowSubmit(p3);
+var EscrowRejectFromRpc = makeEscrowReject(p3);
+var EscrowCompleteFromRpc = makeEscrowComplete(p3);
+var EscrowFromRpc = makeEscrow(p3);
+var OperationFromRpc = makeOperation(p3);
+var ClaimTypeFromRpc = makeClaimType(p3);
+var TransactionRelease20260319FromRpc = makeTransactionRelease20260319(p3);
+var TransactionRelease20260407FromRpc = makeTransactionRelease20260407(p3);
+var TransactionFromRpc = makeTransaction(p3);
+var VersionedTransactionFromRpc = makeVersionedTransaction(p3);
+var MultiSigConfigFromRpc = makeMultiSigConfig(p3);
+var MultiSigFromRpc = makeMultiSig(p3);
+var SignatureOrMultiSigFromRpc = makeSignatureOrMultiSig(p3);
+var TransactionEnvelopeFromRpc = makeTransactionEnvelope(p3);
+var ValidatedTransactionFromRpc = makeValidatedTransaction(p3);
+var TransactionCertificateFromRpc = makeTransactionCertificate(p3);
+var NonceRangeFromRpc = makeNonceRange(p3);
+var PageRequestFromRpc = makePageRequest(p3);
+var TokenMetadataFromRpc = makeTokenMetadata(p3);
+var AccountInfoResponseFromRpc = makeAccountInfoResponse(p3);
+var TokenInfoResponseFromRpc = makeTokenInfoResponse(p3);
+var SubmitTransactionResponseFromRpc = makeSubmitTransactionResponse(p3);
+var ConfirmTransactionResponseFromRpc = makeConfirmTransactionResponse(p3);
+var ProxySubmitTransactionResultFromRpc = makeProxySubmitTransactionResult(p3);
+var EscrowJobRecordFromRpc = makeEscrowJobRecord(p3);
+var EscrowJobWithCertsFromRpc = makeEscrowJobWithCerts(p3);
+var SubmitTransactionParamsFromRpc = makeSubmitTransactionParams(p3);
+var FaucetDripParamsFromRpc = makeFaucetDripParams(p3);
+var GetAccountInfoParamsFromRpc = makeGetAccountInfoParams(p3);
+var GetPendingMultisigParamsFromRpc = makeGetPendingMultisigParams(p3);
+var GetTokenInfoParamsFromRpc = makeGetTokenInfoParams(p3);
+var GetTransactionCertificatesParamsFromRpc = makeGetTransactionCertificatesParams(p3);
+
+// src/schemas/networks.ts
+var AllSetChainTokenSchema = Schema19.Struct({
+  evmAddress: Schema19.String,
+  fastTokenId: Schema19.String,
+  decimals: Schema19.Number
+});
+var AllSetChainSchema = Schema19.Struct({
+  chainId: Schema19.Number,
+  bridgeContract: Schema19.String,
+  fastBridgeAddress: Schema19.String,
+  relayerUrl: Schema19.String,
+  evmRpcUrl: Schema19.String,
+  evmExplorerUrl: Schema19.String,
+  tokens: Schema19.Record({ key: Schema19.String, value: AllSetChainTokenSchema })
+});
+var AllSetConfigSchema = Schema19.Struct({
+  crossSignUrl: Schema19.String,
+  portalApiUrl: Schema19.String,
+  chains: Schema19.Record({ key: Schema19.String, value: AllSetChainSchema })
+});
+var NetworkConfigSchema = Schema19.Struct({
+  url: Schema19.String,
+  explorerUrl: Schema19.String,
+  networkId: NetworkId,
+  allSet: Schema19.optional(AllSetConfigSchema)
+});
+var BundledNetworksSchema = Schema19.Record({
+  key: Schema19.String,
+  value: NetworkConfigSchema
+});
+
+// src/services/storage/network.ts
+var getDefaultNetwork = (db) => db.select().from(metadata).where(eq(metadata.key, "default_network")).get();
+var listCustomNetworks = (db) => db.select({ name: customNetworks.name }).from(customNetworks).all();
+var getCustomNetwork = (db, name) => db.select().from(customNetworks).where(eq(customNetworks.name, name)).get();
+var setDefaultNetwork = (db, name) => db.insert(metadata).values({ key: "default_network", value: name }).onConflictDoUpdate({ target: metadata.key, set: { value: name } }).run();
+var deleteCustomNetwork = (db, name) => db.delete(customNetworks).where(eq(customNetworks.name, name)).run();
+var getDefault = (handle) => Effect.flatMap(
+  handle.query(
+    (db) => getDefaultNetwork(db),
+    "Failed to get default network"
+  ),
+  (row) => row?.value !== void 0 ? Effect.succeed(row.value) : Effect.fail(new NoDefaultNetworkError())
+);
+var resolve = (context, name) => Effect.gen(function* () {
+  const bundled = context.config.getBundledNetwork(name);
+  if (bundled) return bundled;
+  const row = yield* context.handle.query(
+    (db) => getCustomNetwork(db, name),
+    "Failed to get network config"
+  );
+  if (!row) {
+    return yield* Effect.fail(new NetworkNotFoundError({ name }));
+  }
+  const json = JSON.parse(row.config);
+  return yield* Schema20.decodeUnknown(NetworkConfigSchema)(json).pipe(
+    Effect.mapError(() => new InvalidNetworkConfigError({ name }))
+  );
+});
+var list = (context) => Effect.gen(function* () {
+  const defaultName = yield* getDefault(context.handle);
+  const customRows = yield* context.handle.query(
+    (db) => listCustomNetworks(db),
+    "Failed to list networks"
+  );
+  const names = [
+    ...Object.keys(context.config.bundledNetworks),
+    ...customRows.map((r) => r.name)
+  ];
+  return names.map((name) => {
+    const type = context.config.isBundledNetwork(name) ? "bundled" : "custom";
+    const isDefault = name === defaultName;
+    return { name, type, isDefault };
+  });
+});
+var setDefault = (context, name) => Effect.gen(function* () {
+  if (!context.config.isBundledNetwork(name)) {
+    const row = yield* context.handle.query(
+      (db) => getCustomNetwork(db, name),
+      "Failed to get network config"
+    );
+    if (!row) return yield* Effect.fail(new NetworkNotFoundError({ name }));
+  }
+  yield* context.handle.query(
+    (db) => setDefaultNetwork(db, name),
+    "Failed to set default network"
+  );
+});
+var add = (context, name, configPath) => Effect.gen(function* () {
+  if (context.config.isBundledNetwork(name)) {
+    return yield* Effect.fail(new ReservedNameError({ name }));
+  }
+  const existing = yield* context.handle.query(
+    (db) => getCustomNetwork(db, name),
+    "Failed to check existing networks"
+  );
+  if (existing) {
+    return yield* Effect.fail(new NetworkExistsError({ name }));
+  }
+  const raw = yield* Effect.try({
+    try: () => readFileSync(configPath, "utf-8"),
+    catch: (cause) => new FileIOError({
+      message: `Failed to read network config file at "${configPath}"`,
+      cause
+    })
+  });
+  yield* Schema20.decodeUnknown(NetworkConfigSchema)(JSON.parse(raw)).pipe(
+    Effect.mapError(() => new InvalidNetworkConfigError({ name }))
+  );
+  yield* context.handle.query(
+    (db) => db.insert(customNetworks).values({ name, config: raw }).run(),
+    "Failed to save network config"
+  );
+});
+var remove = (context, name) => Effect.gen(function* () {
+  if (context.config.isBundledNetwork(name)) {
+    return yield* Effect.fail(new ReservedNameError({ name }));
+  }
+  const row = yield* context.handle.query(
+    (db) => getCustomNetwork(db, name),
+    "Failed to check network exists"
+  );
+  if (!row) {
+    return yield* Effect.fail(new NetworkNotFoundError({ name }));
+  }
+  const defaultName = yield* getDefault(context.handle);
+  if (defaultName === name) {
+    return yield* Effect.fail(new DefaultNetworkError({ name }));
+  }
+  yield* context.handle.query(
+    (db) => deleteCustomNetwork(db, name),
+    "Failed to remove network"
+  );
+});
+var ServiceEffect = Effect.gen(function* () {
+  const handle = yield* DatabaseService;
+  const config = yield* AppConfig;
+  const context = { handle, config };
+  return {
+    resolve: (name) => resolve(context, name),
+    list: () => list(context),
+    setDefault: (name) => setDefault(context, name),
+    add: (name, configPath) => add(context, name, configPath),
+    remove: (name) => remove(context, name),
+    getDefault: () => getDefault(context.handle)
+  };
+});
+var NetworkConfigService = class extends Effect.Service()(
+  "NetworkConfigService",
+  { effect: ServiceEffect }
+) {
+};
+
+export {
+  LatestTransactionVersion,
+  SignatureFromInput,
+  AddressFromRest,
+  TokenIdFromRest,
+  bcs_layout_exports,
+  GetAccountInfoInput,
+  GetPendingMultisigInput,
+  GetTokenInfoInput,
+  GetTransactionCertificatesInput,
+  GetEscrowJobInput,
+  GetEscrowJobsInput,
+  PrivateKeyFromInput,
+  getTransactionVersionConfig,
+  VersionedTransactionFromBcs,
+  SignatureOrMultiSigFromBcs,
+  TransactionEnvelopeFromRest,
+  TransactionCertificateFromRest,
+  AccountInfoResponseFromRest,
+  TokenInfoResponseFromRest,
+  ProxySubmitTransactionResultFromRest,
+  EscrowJobRecordFromRest,
+  EscrowJobWithCertsFromRest,
+  TransactionCertificateFromRpc,
+  NetworkConfigService
+};
+/*! Bundled license information:
+
+@scure/base/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/