@joai/warps-adapter-fastset 1.0.0-beta.58

package/dist/index.mjs

@@ -0,0 +1,2789 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/main.ts
+import {
+  WarpChainName
+} from "@joai/warps";
+
+// src/helpers/encode.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function uint8ArrayToHex(uint8Array) {
+  return Buffer.from(uint8Array).toString("hex");
+}
+function hexToUint8Array(hex) {
+  return new Uint8Array(Buffer.from(hex, "hex"));
+}
+
+// src/helpers/general.ts
+import { getProviderConfig } from "@joai/warps";
+
+// src/sdk/FastsetClient.ts
+import * as bech32 from "bech32";
+
+// ../../node_modules/@scure/base/lib/esm/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 id2 = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id2);
+  const decode = args.map((x) => x.decode).reduce(wrap, id2);
+  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/@mysten/utils/dist/esm/b58.js
+var toBase58 = (buffer) => base58.encode(buffer);
+var fromBase58 = (str) => base58.decode(str);
+
+// ../../node_modules/@mysten/utils/dist/esm/b64.js
+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/@mysten/utils/dist/esm/hex.js
+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/@mysten/bcs/dist/esm/uleb.js
+function ulebEncode(num) {
+  let bigNum = BigInt(num);
+  const arr = [];
+  let len = 0;
+  if (bigNum === 0n) {
+    return [0];
+  }
+  while (bigNum > 0) {
+    arr[len] = Number(bigNum & 0x7fn);
+    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/@mysten/bcs/dist/esm/reader.js
+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 value2 = this.read32();
+    const result = value2.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 value2 = BigInt(this.read64());
+    const result = value2.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 value2 = BigInt(this.read128());
+    const result = value2.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 buffer = new Uint8Array(this.dataView.buffer, start);
+    const { value, length } = ulebDecode(buffer);
+    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/@mysten/bcs/dist/esm/utils.js
+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/@mysten/bcs/dist/esm/writer.js
+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}
+   */
+  // oxlint-disable-next-line require-yields
+  *[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/@mysten/bcs/dist/esm/bcs-type.js
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _write;
+var _serialize;
+var _schema;
+var _bytes;
+var _BcsType = class _BcsType2 {
+  constructor(options) {
+    __privateAdd(this, _write);
+    __privateAdd(this, _serialize);
+    this.name = options.name;
+    this.read = options.read;
+    this.serializedSize = options.serializedSize ?? (() => null);
+    __privateSet(this, _write, options.write);
+    __privateSet(this, _serialize, options.serialize ?? ((value, options2) => {
+      const writer = new BcsWriter({
+        initialSize: this.serializedSize(value) ?? void 0,
+        ...options2
+      });
+      __privateGet(this, _write).call(this, value, writer);
+      return writer.toBytes();
+    }));
+    this.validate = options.validate ?? (() => {
+    });
+  }
+  write(value, writer) {
+    this.validate(value);
+    __privateGet(this, _write).call(this, value, writer);
+  }
+  serialize(value, options) {
+    this.validate(value);
+    return new SerializedBcs(this, __privateGet(this, _serialize).call(this, 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) => __privateGet(this, _write).call(this, input ? input(value) : value, writer),
+      serializedSize: (value) => this.serializedSize(input ? input(value) : value),
+      serialize: (value, options) => __privateGet(this, _serialize).call(this, input ? input(value) : value, options),
+      validate: (value) => {
+        validate?.(value);
+        this.validate(input ? input(value) : value);
+      }
+    });
+  }
+};
+_write = /* @__PURE__ */ new WeakMap();
+_serialize = /* @__PURE__ */ new WeakMap();
+var BcsType = _BcsType;
+var SERIALIZED_BCS_BRAND = /* @__PURE__ */ Symbol.for("@mysten/serialized-bcs");
+var SerializedBcs = class {
+  constructor(schema, bytes) {
+    __privateAdd(this, _schema);
+    __privateAdd(this, _bytes);
+    __privateSet(this, _schema, schema);
+    __privateSet(this, _bytes, bytes);
+  }
+  // Used to brand SerializedBcs so that they can be identified, even between multiple copies
+  // of the @mysten/bcs package are installed
+  get [SERIALIZED_BCS_BRAND]() {
+    return true;
+  }
+  toBytes() {
+    return __privateGet(this, _bytes);
+  }
+  toHex() {
+    return toHex(__privateGet(this, _bytes));
+  }
+  toBase64() {
+    return toBase64(__privateGet(this, _bytes));
+  }
+  toBase58() {
+    return toBase58(__privateGet(this, _bytes));
+  }
+  parse() {
+    return __privateGet(this, _schema).parse(__privateGet(this, _bytes));
+  }
+};
+_schema = /* @__PURE__ */ new WeakMap();
+_bytes = /* @__PURE__ */ new WeakMap();
+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();
+      const bytes = reader.readBytes(length);
+      return fromBytes(bytes);
+    },
+    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(
+          ([name2]) => Object.hasOwn(fields, name2)
+        )[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/@mysten/bcs/dist/esm/bcs.js
+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 map(keyType, valueType) {
+  return bcs.vector(bcs.tuple([keyType, valueType])).transform({
+    name: `Map<${keyType.name}, ${valueType.name}>`,
+    input: (value) => {
+      return [...value.entries()];
+    },
+    output: (value) => {
+      const result = /* @__PURE__ */ new Map();
+      for (const [key, val] of value) {
+        result.set(key, val);
+      }
+      return result;
+    }
+  });
+}
+var bcs = {
+  /**
+   * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
+   * @example
+   * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
+   */
+  u8(options) {
+    return uIntBcsType({
+      readMethod: "read8",
+      writeMethod: "write8",
+      size: 1,
+      maxValue: 2 ** 8 - 1,
+      ...options,
+      name: options?.name ?? "u8"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.
+   * @example
+   * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
+   */
+  u16(options) {
+    return uIntBcsType({
+      readMethod: "read16",
+      writeMethod: "write16",
+      size: 2,
+      maxValue: 2 ** 16 - 1,
+      ...options,
+      name: options?.name ?? "u16"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.
+   * @example
+   * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
+   */
+  u32(options) {
+    return uIntBcsType({
+      readMethod: "read32",
+      writeMethod: "write32",
+      size: 4,
+      maxValue: 2 ** 32 - 1,
+      ...options,
+      name: options?.name ?? "u32"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.
+   * @example
+   * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
+   */
+  u64(options) {
+    return bigUIntBcsType({
+      readMethod: "read64",
+      writeMethod: "write64",
+      size: 8,
+      maxValue: 2n ** 64n - 1n,
+      ...options,
+      name: options?.name ?? "u64"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.
+   * @example
+   * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+   */
+  u128(options) {
+    return bigUIntBcsType({
+      readMethod: "read128",
+      writeMethod: "write128",
+      size: 16,
+      maxValue: 2n ** 128n - 1n,
+      ...options,
+      name: options?.name ?? "u128"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.
+   * @example
+   * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+   */
+  u256(options) {
+    return bigUIntBcsType({
+      readMethod: "read256",
+      writeMethod: "write256",
+      size: 32,
+      maxValue: 2n ** 256n - 1n,
+      ...options,
+      name: options?.name ?? "u256"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write boolean values.
+   * @example
+   * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
+   */
+  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}`);
+        }
+      }
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write unsigned LEB encoded integers
+   * @example
+   *
+   */
+  uleb128(options) {
+    return dynamicSizeBcsType({
+      read: (reader) => reader.readULEB(),
+      serialize: (value) => {
+        return Uint8Array.from(ulebEncode(value));
+      },
+      ...options,
+      name: options?.name ?? "uleb128"
+    });
+  },
+  /**
+   * Creates a BcsType representing a fixed length byte array
+   * @param size The number of bytes this types represents
+   * @example
+   * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
+   */
+  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}`);
+        }
+      }
+    });
+  },
+  /**
+   * Creates a BcsType representing a variable length byte array
+   *
+   * @example
+   * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]
+   */
+  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}`);
+        }
+      }
+    });
+  },
+  /**
+   * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded
+   * @example
+   * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
+   */
+  string(options) {
+    return stringLikeBcsType({
+      toBytes: (value) => new TextEncoder().encode(value),
+      fromBytes: (bytes) => new TextDecoder().decode(bytes),
+      ...options,
+      name: options?.name ?? "string"
+    });
+  },
+  /**
+   * Creates a BcsType that represents a fixed length array of a given type
+   * @param size The number of elements in the array
+   * @param type The BcsType of each element in the array
+   * @example
+   * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
+   */
+  fixedArray,
+  /**
+   * Creates a BcsType representing an optional value
+   * @param type The BcsType of the optional value
+   * @example
+   * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
+   * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
+   */
+  option,
+  /**
+   * Creates a BcsType representing a variable length vector of a given type
+   * @param type The BcsType of each element in the vector
+   *
+   * @example
+   * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
+   */
+  vector,
+  /**
+   * Creates a BcsType representing a tuple of a given set of types
+   * @param types The BcsTypes for each element in the tuple
+   *
+   * @example
+   * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
+   * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
+   */
+  tuple(fields, options) {
+    return new BcsTuple({
+      fields,
+      ...options
+    });
+  },
+  /**
+   * Creates a BcsType representing a struct of a given set of fields
+   * @param name The name of the struct
+   * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized
+   *
+   * @example
+   * const struct = bcs.struct('MyStruct', {
+   *  a: bcs.u8(),
+   *  b: bcs.string(),
+   * })
+   * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
+   */
+  struct(name, fields, options) {
+    return new BcsStruct({
+      name,
+      fields,
+      ...options
+    });
+  },
+  /**
+   * Creates a BcsType representing an enum of a given set of options
+   * @param name The name of the enum
+   * @param values The values of the enum. The order of the values affects how data is serialized and deserialized.
+   * null can be used to represent a variant with no data.
+   *
+   * @example
+   * const enum = bcs.enum('MyEnum', {
+   *   A: bcs.u8(),
+   *   B: bcs.string(),
+   *   C: null,
+   * })
+   * enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]
+   * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
+   * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
+   */
+  enum(name, fields, options) {
+    return new BcsEnum({
+      name,
+      fields,
+      ...options
+    });
+  },
+  /**
+   * Creates a BcsType representing a map of a given key and value type
+   * @param keyType The BcsType of the key
+   * @param valueType The BcsType of the value
+   * @example
+   * const map = bcs.map(bcs.u8(), bcs.string())
+   * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
+   */
+  map,
+  /**
+   * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.
+   * @param cb A callback that returns the BcsType
+   */
+  lazy(cb) {
+    return lazyBcsType(cb);
+  }
+};
+
+// src/sdk/types.ts
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
+var Bytes32 = bcs.fixedArray(32, bcs.u8());
+var Bytes64 = bcs.fixedArray(64, bcs.u8());
+var PublicKey = Bytes32;
+var Signature = Bytes64;
+var Address = bcs.enum("Address", {
+  External: PublicKey,
+  FastSet: PublicKey
+});
+var Amount = bcs.u256().transform({
+  // CAUTION: When we build a transaction object, we must use a hex encoded string because the
+  // validator expects amounts to be in hex. However, bcs.u256() by default expects a decimal
+  // string. Therefore, we must transform the input amount from hex to decimal here.
+  input: (val) => hexToDecimal(val.toString()),
+  output: (value) => value
+});
+var Balance = bcs.string().transform({
+  input: (val) => val,
+  output: (value) => value
+});
+var UserData = bcs.option(Bytes32);
+var Nonce = bcs.u64();
+var Quorum = bcs.u64();
+var TokenId = Bytes32;
+var Transfer = bcs.struct("Transfer", {
+  amount: Amount,
+  user_data: UserData
+});
+var TokenTransfer = bcs.struct("TokenTransfer", {
+  token_id: TokenId,
+  amount: Amount,
+  user_data: UserData
+});
+var TokenCreation = bcs.struct("TokenCreation", {
+  token_name: bcs.string(),
+  decimals: bcs.u8(),
+  initial_amount: Amount,
+  mints: bcs.vector(PublicKey),
+  user_data: UserData
+});
+var AddressChange = bcs.enum("AddressChange", {
+  Add: PublicKey,
+  Remove: PublicKey
+});
+var TokenManagement = bcs.struct("TokenManagement", {
+  token_id: TokenId,
+  update_id: Nonce,
+  new_admin: bcs.option(PublicKey),
+  mints: bcs.vector(bcs.tuple([AddressChange, PublicKey])),
+  user_data: UserData
+});
+var Mint = bcs.struct("Mint", {
+  token_id: TokenId,
+  amount: Amount
+});
+var ClaimData = bcs.vector(bcs.u8());
+var ExternalClaimBody = bcs.struct("ExternalClaimBody", {
+  verifier_committee: bcs.vector(PublicKey),
+  verifier_quorum: Quorum,
+  claim_data: ClaimData
+});
+var ExternalClaim = bcs.struct("ExternalClaim", {
+  claim: ExternalClaimBody,
+  signatures: bcs.vector(bcs.tuple([PublicKey, Signature]))
+});
+var ClaimType = bcs.enum("ClaimType", {
+  Transfer,
+  TokenTransfer,
+  TokenCreation,
+  TokenManagement,
+  Mint,
+  ExternalClaim
+});
+var Transaction = bcs.struct("Transaction", {
+  sender: PublicKey,
+  recipient: Address,
+  nonce: Nonce,
+  timestamp_nanos: bcs.u128(),
+  claim: ClaimType
+});
+var SubmitTransactionResponse = bcs.struct("SubmitTransactionResponse", {
+  validator: PublicKey,
+  signature: Signature,
+  next_nonce: Nonce,
+  transaction_hash: bcs.vector(bcs.u8())
+});
+var TransactionEnvelope = bcs.struct("TransactionEnvelope", {
+  transaction: Transaction,
+  signature: Signature
+});
+var TransactionCertificate = bcs.struct("TransactionCertificate", {
+  envelope: TransactionEnvelope,
+  signatures: bcs.vector(bcs.tuple([PublicKey, Signature]))
+});
+function hexToDecimal(hex) {
+  return BigInt(`0x${hex}`).toString();
+}
+
+// src/sdk/FastsetClient.ts
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
+var id = 0;
+var FastsetClient = class {
+  constructor(proxyUrl) {
+    this.proxyUrl = proxyUrl;
+  }
+  async request(url, method, params) {
+    const requestId = id++;
+    const request = this.buildJsonRpcRequest(requestId, method, params);
+    const headers = { "Content-Type": "application/json" };
+    const body = this.jsonSerialize(request);
+    try {
+      const response = await fetch(url, { method: "POST", headers, body });
+      if (!response.ok) {
+        return { jsonrpc: "2.0", id: requestId, error: { code: response.status, message: response.statusText } };
+      }
+      try {
+        return await response.json();
+      } catch {
+        return { jsonrpc: "2.0", id: requestId, error: { code: -32700, message: "Parse error" } };
+      }
+    } catch {
+      return { jsonrpc: "2.0", id: requestId, error: { code: -32603, message: "Internal error" } };
+    }
+  }
+  buildJsonRpcRequest(id2, method, params) {
+    return { jsonrpc: "2.0", id: id2, method, params };
+  }
+  jsonSerialize(data) {
+    return JSON.stringify(data, (k, v) => {
+      if (v instanceof Uint8Array) {
+        return Array.from(v);
+      }
+      return v;
+    });
+  }
+  async getAccountInfo(address) {
+    return this.request(this.proxyUrl, "set_proxy_getAccountInfo", { address, token_balances_filter: [] });
+  }
+  async getTokenInfo(tokenIds) {
+    return this.request(this.proxyUrl, "set_proxy_getTokenInfo", { tokenIds: [Array.from(tokenIds)] });
+  }
+  async getNextNonce(address) {
+    const addressBytes = typeof address === "string" ? this.addressToBytes(address) : address;
+    const accountInfoRes = await this.getAccountInfo(addressBytes);
+    return accountInfoRes.result?.next_nonce ?? 0;
+  }
+  async submitTransaction(tx, signature) {
+    const submitTxReq = { transaction: tx, signature };
+    const response = await this.request(this.proxyUrl, "set_proxy_submitTransaction", submitTxReq);
+    const proxyCert = this.parse_TransactionCertificate(response.result);
+    console.log("FastSet Transaction Certificate:", proxyCert);
+    return proxyCert;
+  }
+  parse_TransactionCertificate(res) {
+    let bcs_bytes = TransactionCertificate.serialize(res).toBytes();
+    let bcs_value = TransactionCertificate.parse(bcs_bytes);
+    return bcs_value;
+  }
+  addressToBytes(address) {
+    try {
+      const decoded = bech32.bech32m.decode(address);
+      return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+    } catch {
+      const decoded = bech32.bech32.decode(address);
+      return new Uint8Array(bech32.bech32.fromWords(decoded.words));
+    }
+  }
+  static decodeBech32Address(address) {
+    try {
+      const decoded = bech32.bech32m.decode(address);
+      return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+    } catch {
+      const decoded = bech32.bech32.decode(address);
+      return new Uint8Array(bech32.bech32.fromWords(decoded.words));
+    }
+  }
+  static encodeBech32Address(publicKey) {
+    const words = bech32.bech32m.toWords(publicKey);
+    return bech32.bech32m.encode("set", words);
+  }
+};
+
+// src/helpers/general.ts
+var getConfiguredFastsetClient = (config, chain2) => {
+  const providerConfig = getProviderConfig(config, chain2.name, config.env, chain2.defaultApiUrl);
+  return new FastsetClient(providerConfig.url);
+};
+
+// src/tokens/fastset.ts
+var FastsetTokens = [
+  {
+    chain: "fastset",
+    identifier: "0x37bb8861c49c6f59d869634557245b8640c2de6a2d3dffd6ad4065f6f67989f1",
+    name: "Ethereum",
+    symbol: "ETH",
+    decimals: 18,
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/eth-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/eth-black.svg"
+    },
+    amount: 0n
+  },
+  {
+    chain: "fastset",
+    identifier: "0ee63eaa3ff9bf6e1c84a70133c5461e6e06d3787ed93200b924a6b82f0f35ff",
+    name: "Bitcoin",
+    symbol: "BTC",
+    decimals: 8,
+    logoUrl: "https://assets.coingecko.com/coins/images/1/small/bitcoin.png",
+    amount: 0n
+  },
+  {
+    chain: "fastset",
+    identifier: "b69f0d3a4d7609367bd893ee3191e48b3047f2c4ccd21728c2441bcc2154f70c",
+    name: "Solana",
+    symbol: "SOL",
+    decimals: 9,
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/sol.svg",
+    amount: 0n
+  },
+  {
+    chain: "fastset",
+    identifier: "c83166ed4e5e3ca88f7b2cf0ce2d310fa8c4d2ee2fc90d741f7b2040279b2687",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png",
+    amount: 0n
+  },
+  {
+    chain: "fastset",
+    identifier: "0xfa575e7000000000000000000000000000000000000000000000000000000000",
+    name: "Wrapped SET",
+    symbol: "WSET",
+    decimals: 18,
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/set-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/set-black.svg"
+    },
+    amount: 0n
+  }
+];
+
+// src/tokens.ts
+var KnownTokens = {
+  mainnet: FastsetTokens,
+  testnet: FastsetTokens,
+  devnet: FastsetTokens
+};
+var findKnownTokenBySymbol = (symbol, env = "mainnet") => {
+  const tokens = KnownTokens[env] || [];
+  return tokens.find((token) => token.symbol === symbol) || null;
+};
+var findKnownTokenById = (id2, env = "mainnet") => {
+  const tokens = KnownTokens[env] || [];
+  return tokens.find((token) => token.identifier === id2) || null;
+};
+
+// src/WarpFastsetDataLoader.ts
+var WarpFastsetDataLoader = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.client = getConfiguredFastsetClient(config, chain2);
+  }
+  async getAccount(address) {
+    const addressBytes = FastsetClient.decodeBech32Address(address);
+    const accountInfo = await this.client.getAccountInfo(addressBytes);
+    return { chain: this.chain.name, address, balance: BigInt(parseInt(accountInfo.result?.balance ?? "0", 16)) };
+  }
+  async getAccountAssets(address) {
+    const addressBytes = FastsetClient.decodeBech32Address(address);
+    const accountInfo = await this.client.getAccountInfo(addressBytes);
+    const assets = [];
+    const balance = BigInt(parseInt(accountInfo.result?.balance ?? "0", 16));
+    if (balance > 0n) {
+      assets.push({ ...this.chain.nativeToken, amount: balance });
+    }
+    for (const [tokenId, tokenBalance] of accountInfo.result?.token_balance ?? []) {
+      const amount = BigInt(parseInt(tokenBalance, 16));
+      if (amount > 0n) {
+        const assetInfo = await this.getAssetInfo(Buffer.from(tokenId).toString("hex"));
+        if (!assetInfo) continue;
+        assets.push({
+          chain: this.chain.name,
+          identifier: Buffer.from(tokenId).toString("hex"),
+          symbol: assetInfo.symbol,
+          name: assetInfo.name,
+          decimals: assetInfo.decimals,
+          logoUrl: assetInfo.logoUrl,
+          amount
+        });
+      }
+    }
+    return assets;
+  }
+  async getAsset(identifier) {
+    if (identifier === this.chain.nativeToken.identifier) {
+      return this.chain.nativeToken;
+    }
+    const assetInfo = await this.getAssetInfo(identifier);
+    if (!assetInfo) {
+      return null;
+    }
+    return {
+      chain: this.chain.name,
+      identifier,
+      symbol: assetInfo.symbol,
+      name: assetInfo.name,
+      decimals: assetInfo.decimals,
+      logoUrl: assetInfo.logoUrl,
+      amount: 0n
+    };
+  }
+  async getAction(identifier, awaitCompleted = false) {
+    return null;
+  }
+  async getAccountActions(address, options) {
+    return [];
+  }
+  async getAssetInfo(identifier) {
+    const knownToken = findKnownTokenById(identifier, this.config.env) || findKnownTokenBySymbol(identifier, this.config.env);
+    if (knownToken) {
+      return knownToken;
+    }
+    const tokenInfo = await this.client.getTokenInfo(hexToUint8Array(identifier));
+    const metadata = tokenInfo.result?.requested_token_metadata[0]?.[1];
+    if (metadata) {
+      return {
+        chain: this.chain.name,
+        identifier,
+        symbol: metadata.token_name,
+        name: metadata.token_name,
+        decimals: metadata.decimals,
+        logoUrl: null
+      };
+    }
+    return null;
+  }
+};
+
+// src/WarpFastsetExecutor.ts
+import {
+  getWarpActionByIndex,
+  getWarpWalletAddressFromConfig
+} from "@joai/warps";
+var WarpFastsetExecutor = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.client = getConfiguredFastsetClient(this.config, this.chain);
+  }
+  async createTransaction(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (action.type === "transfer") return this.createTransferTransaction(executable);
+    if (action.type === "contract") return this.createContractCallTransaction(executable);
+    if (action.type === "query") throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeQuery instead");
+    if (action.type === "collect")
+      throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeCollect instead");
+    throw new Error(`WarpFastsetExecutor: Invalid action type (${action.type})`);
+  }
+  async createTransferTransaction(executable) {
+    if (!executable.destination) throw new Error("WarpFastsetExecutor: createTransfer - destination not set");
+    const userWallet = getWarpWalletAddressFromConfig(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
+    const senderPubKey = FastsetClient.decodeBech32Address(userWallet);
+    const recipientPubKey = FastsetClient.decodeBech32Address(executable.destination);
+    const nonce = await this.client.getNextNonce(userWallet);
+    const isSingleNativeTransfer = executable.transfers.length === 1 && executable.transfers[0].identifier === this.chain.nativeToken?.identifier;
+    const nativeAmountInTransfers = isSingleNativeTransfer ? executable.transfers[0].amount : 0n;
+    const nativeAmountTotal = nativeAmountInTransfers + executable.value;
+    if (nativeAmountTotal > 0n) {
+      return {
+        sender: senderPubKey,
+        recipient: { FastSet: recipientPubKey },
+        nonce,
+        timestamp_nanos: BigInt(Date.now()) * 1000000n,
+        claim: { Transfer: { amount: nativeAmountTotal.toString(16), user_data: null } }
+      };
+    } else if (executable.transfers.length === 1) {
+      return {
+        sender: senderPubKey,
+        recipient: { FastSet: recipientPubKey },
+        nonce,
+        timestamp_nanos: BigInt(Date.now()) * 1000000n,
+        claim: {
+          TokenTransfer: {
+            token_id: hexToUint8Array(executable.transfers[0].identifier),
+            amount: executable.transfers[0].amount.toString(16),
+            user_data: null
+          }
+        }
+      };
+    } else {
+      throw new Error("WarpFastsetExecutor: No valid transfers provided (maximum 1 transfer allowed)");
+    }
+  }
+  async createContractCallTransaction(executable) {
+    throw new Error("WarpFastsetExecutor: Not implemented");
+  }
+  async executeQuery(executable) {
+    throw new Error("WarpFastsetExecutor: Not implemented");
+  }
+};
+
+// src/WarpFastsetExplorer.ts
+var HEX_PREFIX = "0x";
+var WarpFastsetExplorer = class {
+  constructor(_chainInfo, _config) {
+    this._chainInfo = _chainInfo;
+    this._config = _config;
+    this.explorerUrl = "https://explorer.fastset.xyz";
+  }
+  getAccountUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
+  }
+  getTransactionUrl(hash) {
+    return `${this.explorerUrl}/txs/${HEX_PREFIX}${hash}`;
+  }
+  getAssetUrl(identifier) {
+    return `${this.explorerUrl}/asset/${HEX_PREFIX}${identifier}`;
+  }
+  getContractUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
+  }
+};
+
+// src/WarpFastsetOutput.ts
+import {
+  evaluateOutputCommon,
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig2,
+  parseOutputOutIndex,
+  WarpConstants
+} from "@joai/warps";
+
+// src/WarpFastsetSerializer.ts
+import {
+  WarpSerializer
+} from "@joai/warps";
+var WarpFastsetSerializer = class {
+  constructor() {
+    this.coreSerializer = new WarpSerializer();
+  }
+  typedToString(value) {
+    if (typeof value === "string") {
+      return `string:${value}`;
+    }
+    if (typeof value === "number") {
+      return `number:${value}`;
+    }
+    if (typeof value === "boolean") {
+      return `boolean:${value}`;
+    }
+    if (typeof value === "bigint") {
+      return `biguint:${value.toString()}`;
+    }
+    if (Array.isArray(value)) {
+      const items = value.map((item) => this.typedToString(item)).join(",");
+      return `array:${items}`;
+    }
+    if (value === null) {
+      return "null:null";
+    }
+    if (value === void 0) {
+      return "undefined:undefined";
+    }
+    return `string:${String(value)}`;
+  }
+  typedToNative(value) {
+    if (typeof value === "string") {
+      return ["string", value];
+    }
+    if (typeof value === "number") {
+      return ["number", value];
+    }
+    if (typeof value === "boolean") {
+      return ["boolean", value];
+    }
+    if (typeof value === "bigint") {
+      return ["biguint", value.toString()];
+    }
+    return ["string", String(value)];
+  }
+  nativeToTyped(type, value) {
+    switch (type) {
+      case "string":
+        return String(value);
+      case "number":
+        return Number(value);
+      case "boolean":
+        return Boolean(value);
+      case "biguint":
+        return BigInt(value);
+      case "address":
+        return String(value);
+      case "hex":
+        return String(value);
+      default:
+        return String(value);
+    }
+  }
+  nativeToType(type) {
+    switch (type) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "biguint":
+        return "biguint";
+      case "address":
+        return "address";
+      case "hex":
+        return "hex";
+      default:
+        return "string";
+    }
+  }
+  stringToTyped(value) {
+    const colonIndex = value.indexOf(":");
+    if (colonIndex === -1) {
+      return value;
+    }
+    const type = value.substring(0, colonIndex);
+    const stringValue = value.substring(colonIndex + 1);
+    switch (type) {
+      case "string":
+        return stringValue;
+      case "number":
+        return Number(stringValue);
+      case "boolean":
+        return stringValue === "true";
+      case "biguint":
+        return BigInt(stringValue);
+      case "array":
+        return stringValue.split(",").map((item) => this.stringToTyped(item));
+      case "null":
+        return null;
+      case "undefined":
+        return void 0;
+      default:
+        return stringValue;
+    }
+  }
+};
+
+// src/WarpFastsetOutput.ts
+var WarpFastsetOutput = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.serializer = new WarpFastsetSerializer();
+  }
+  async getActionExecution(warp, actionIndex, tx) {
+    const success = this.isTransactionSuccessful(tx);
+    const transactionHash = this.extractTransactionHash(tx);
+    const blockNumber = this.extractBlockNumber(tx);
+    const timestamp = this.extractTimestamp(tx);
+    const rawValues = [transactionHash, blockNumber, timestamp];
+    const stringValues = rawValues.map((v) => String(v));
+    return {
+      status: success ? "success" : "error",
+      warp,
+      action: 0,
+      user: getWarpWalletAddressFromConfig2(this.config, this.chain.name),
+      txHash: transactionHash,
+      tx,
+      next: null,
+      values: { string: stringValues, native: rawValues, mapped: {} },
+      output: {},
+      messages: {},
+      destination: null,
+      resolvedInputs: []
+    };
+  }
+  async extractQueryOutput(warp, typedValues, actionIndex, inputs) {
+    const stringValues = typedValues.map((t) => this.serializer.typedToString(t));
+    const nativeValues = typedValues.map((t) => this.serializer.typedToNative(t)[1]);
+    const values = { string: stringValues, native: nativeValues, mapped: {} };
+    let output = {};
+    if (!warp.output) return { values, output };
+    const getNestedValue = (path) => {
+      const match = path.match(/^out\[(\d+)\]$/);
+      if (match) {
+        const index = parseInt(match[1]) - 1;
+        return nativeValues[index];
+      }
+      const indices = path.split(".").slice(1).map((i) => parseInt(i) - 1);
+      if (indices.length === 0) return void 0;
+      let value = nativeValues[indices[0]];
+      for (let i = 1; i < indices.length; i++) {
+        if (value === void 0 || value === null) return void 0;
+        value = value[indices[i]];
+      }
+      return value;
+    };
+    for (const [key, path] of Object.entries(warp.output)) {
+      if (path.startsWith(WarpConstants.Transform.Prefix)) continue;
+      const currentActionIndex = parseOutputOutIndex(path);
+      if (currentActionIndex !== null && currentActionIndex !== actionIndex) {
+        output[key] = null;
+        continue;
+      }
+      if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
+        const value = getNestedValue(path);
+        output[key] = value || null;
+      } else {
+        output[key] = path;
+      }
+    }
+    return {
+      values,
+      output: await evaluateOutputCommon(
+        warp,
+        output,
+        actionIndex,
+        inputs,
+        this.serializer.coreSerializer,
+        this.config
+      )
+    };
+  }
+  isTransactionSuccessful(tx) {
+    if (!tx) return false;
+    if (tx.success === false) return false;
+    if (tx.success === true) return true;
+    if (tx.status === "success") return true;
+    if (tx.status === 1) return true;
+    if (tx.result && tx.result.success === true) return true;
+    return false;
+  }
+  extractTransactionHash(tx) {
+    if (!tx) return "";
+    return tx.transaction_hash || tx.transactionHash || tx.hash || tx.result && tx.result.transaction_hash || "";
+  }
+  extractBlockNumber(tx) {
+    if (!tx) return "0";
+    return tx.block_number?.toString() || tx.blockNumber?.toString() || tx.result && tx.result.block_number?.toString() || "0";
+  }
+  extractTimestamp(tx) {
+    if (!tx) return "0";
+    return tx.timestamp?.toString() || tx.timestamp_nanos?.toString() || tx.result && tx.result.timestamp?.toString() || Date.now().toString();
+  }
+};
+
+// src/WarpFastsetWallet.ts
+import {
+  initializeWalletCache
+} from "@joai/warps";
+
+// src/providers/MnemonicWalletProvider.ts
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import {
+  getWarpWalletMnemonicFromConfig,
+  getWarpWalletPrivateKeyFromConfig,
+  normalizeAndValidateMnemonic,
+  normalizeMnemonic,
+  setWarpWalletInConfig,
+  validateMnemonicLength
+} from "@joai/warps";
+
+// src/sdk/ed25519-setup.ts
+import * as ed25519 from "@noble/ed25519";
+
+// ../../node_modules/@noble/hashes/utils.js
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes2(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// ../../node_modules/@noble/hashes/_md.js
+var HashMD = class {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    __publicField(this, "blockLen");
+    __publicField(this, "outputLen");
+    __publicField(this, "padOffset");
+    __publicField(this, "isLE");
+    // For partial updates less than block size
+    __publicField(this, "buffer");
+    __publicField(this, "view");
+    __publicField(this, "finished", false);
+    __publicField(this, "length", 0);
+    __publicField(this, "pos", 0);
+    __publicField(this, "destroyed", false);
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]);
+
+// ../../node_modules/@noble/hashes/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var shrSH = (h, _l, s) => h >>> s;
+var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+// ../../node_modules/@noble/hashes/sha2.js
+var K512 = /* @__PURE__ */ (() => split([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((n) => BigInt(n))))();
+var SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+var SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+var SHA2_64B = class extends HashMD {
+  constructor(outputLen) {
+    super(128, outputLen, 16, false);
+  }
+  // prettier-ignore
+  get() {
+    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+  }
+  // prettier-ignore
+  set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+    this.Ah = Ah | 0;
+    this.Al = Al | 0;
+    this.Bh = Bh | 0;
+    this.Bl = Bl | 0;
+    this.Ch = Ch | 0;
+    this.Cl = Cl | 0;
+    this.Dh = Dh | 0;
+    this.Dl = Dl | 0;
+    this.Eh = Eh | 0;
+    this.El = El | 0;
+    this.Fh = Fh | 0;
+    this.Fl = Fl | 0;
+    this.Gh = Gh | 0;
+    this.Gl = Gl | 0;
+    this.Hh = Hh | 0;
+    this.Hl = Hl | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4) {
+      SHA512_W_H[i] = view.getUint32(offset);
+      SHA512_W_L[i] = view.getUint32(offset += 4);
+    }
+    for (let i = 16; i < 80; i++) {
+      const W15h = SHA512_W_H[i - 15] | 0;
+      const W15l = SHA512_W_L[i - 15] | 0;
+      const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+      const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+      const W2h = SHA512_W_H[i - 2] | 0;
+      const W2l = SHA512_W_L[i - 2] | 0;
+      const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+      const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+      const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+      const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+      SHA512_W_H[i] = SUMh | 0;
+      SHA512_W_L[i] = SUMl | 0;
+    }
+    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    for (let i = 0; i < 80; i++) {
+      const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+      const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+      const CHIh = Eh & Fh ^ ~Eh & Gh;
+      const CHIl = El & Fl ^ ~El & Gl;
+      const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+      const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+      const T1l = T1ll | 0;
+      const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+      const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+      const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+      const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+      Hh = Gh | 0;
+      Hl = Gl | 0;
+      Gh = Fh | 0;
+      Gl = Fl | 0;
+      Fh = Eh | 0;
+      Fl = El | 0;
+      ({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+      Dh = Ch | 0;
+      Dl = Cl | 0;
+      Ch = Bh | 0;
+      Cl = Bl | 0;
+      Bh = Ah | 0;
+      Bl = Al | 0;
+      const All = add3L(T1l, sigma0l, MAJl);
+      Ah = add3H(All, T1h, sigma0h, MAJh);
+      Al = All | 0;
+    }
+    ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+    ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+    ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+    ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+    ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+    ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+    ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+    ({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+  }
+  roundClean() {
+    clean(SHA512_W_H, SHA512_W_L);
+  }
+  destroy() {
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+};
+var _SHA512 = class extends SHA2_64B {
+  constructor() {
+    super(64);
+    __publicField(this, "Ah", SHA512_IV[0] | 0);
+    __publicField(this, "Al", SHA512_IV[1] | 0);
+    __publicField(this, "Bh", SHA512_IV[2] | 0);
+    __publicField(this, "Bl", SHA512_IV[3] | 0);
+    __publicField(this, "Ch", SHA512_IV[4] | 0);
+    __publicField(this, "Cl", SHA512_IV[5] | 0);
+    __publicField(this, "Dh", SHA512_IV[6] | 0);
+    __publicField(this, "Dl", SHA512_IV[7] | 0);
+    __publicField(this, "Eh", SHA512_IV[8] | 0);
+    __publicField(this, "El", SHA512_IV[9] | 0);
+    __publicField(this, "Fh", SHA512_IV[10] | 0);
+    __publicField(this, "Fl", SHA512_IV[11] | 0);
+    __publicField(this, "Gh", SHA512_IV[12] | 0);
+    __publicField(this, "Gl", SHA512_IV[13] | 0);
+    __publicField(this, "Hh", SHA512_IV[14] | 0);
+    __publicField(this, "Hl", SHA512_IV[15] | 0);
+  }
+};
+var sha512 = /* @__PURE__ */ createHasher(
+  () => new _SHA512(),
+  /* @__PURE__ */ oidNist(3)
+);
+
+// src/sdk/ed25519-setup.ts
+ed25519.hashes.sha512 = sha512;
+var ed = ed25519;
+
+// src/providers/MnemonicWalletProvider.ts
+var _MnemonicWalletProvider = class _MnemonicWalletProvider {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.privateKey = null;
+  }
+  async getAddress() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return FastsetClient.encodeBech32Address(publicKey);
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return uint8ArrayToHex(publicKey);
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const privateKey = this.getPrivateKey();
+    const msg = Transaction.serialize(tx);
+    const msgBytes = msg.toBytes();
+    const prefix = new TextEncoder().encode("Transaction::");
+    const dataToSign = new Uint8Array(prefix.length + msgBytes.length);
+    dataToSign.set(prefix, 0);
+    dataToSign.set(msgBytes, prefix.length);
+    const signature = ed.sign(dataToSign, privateKey);
+    return { ...tx, signature };
+  }
+  async signMessage(message) {
+    const privateKey = this.getPrivateKey();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = ed.sign(messageBytes, privateKey);
+    return uint8ArrayToHex(signature);
+  }
+  async importFromMnemonic(mnemonic) {
+    const trimmedMnemonic = normalizeAndValidateMnemonic(mnemonic);
+    const seed = bip39.mnemonicToSeedSync(trimmedMnemonic);
+    const privateKey = seed.slice(0, 32);
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    const walletDetails = {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: uint8ArrayToHex(privateKey),
+      mnemonic: trimmedMnemonic
+    };
+    setWarpWalletInConfig(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async importFromPrivateKey(privateKey) {
+    const privateKeyBytes = Buffer.from(privateKey, "hex");
+    const publicKey = ed.getPublicKey(new Uint8Array(privateKeyBytes));
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    const walletDetails = {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey,
+      mnemonic: null
+    };
+    setWarpWalletInConfig(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async export() {
+    const privateKey = this.getPrivateKey();
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    const privateKeyHex = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: privateKeyHex || null,
+      mnemonic: mnemonic || null
+    };
+  }
+  async generate() {
+    const mnemonicRaw = bip39.generateMnemonic(wordlist, 256);
+    const mnemonic = normalizeMnemonic(mnemonicRaw);
+    validateMnemonicLength(mnemonic);
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const privateKey = seed.slice(0, 32);
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: null,
+      mnemonic
+    };
+  }
+  getPrivateKey() {
+    if (this.privateKey) return this.privateKey;
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (!mnemonic) throw new Error("No mnemonic provided");
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    this.privateKey = seed.slice(0, 32);
+    return this.privateKey;
+  }
+};
+_MnemonicWalletProvider.PROVIDER_NAME = "mnemonic";
+var MnemonicWalletProvider = _MnemonicWalletProvider;
+
+// src/providers/PrivateKeyWalletProvider.ts
+import {
+  getWarpWalletMnemonicFromConfig as getWarpWalletMnemonicFromConfig2,
+  getWarpWalletPrivateKeyFromConfig as getWarpWalletPrivateKeyFromConfig2,
+  setWarpWalletInConfig as setWarpWalletInConfig2
+} from "@joai/warps";
+import * as bip392 from "@scure/bip39";
+var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.privateKey = null;
+  }
+  async getAddress() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return FastsetClient.encodeBech32Address(publicKey);
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return uint8ArrayToHex(publicKey);
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const privateKey = this.getPrivateKey();
+    const msg = Transaction.serialize(tx);
+    const msgBytes = msg.toBytes();
+    const prefix = new TextEncoder().encode("Transaction::");
+    const dataToSign = new Uint8Array(prefix.length + msgBytes.length);
+    dataToSign.set(prefix, 0);
+    dataToSign.set(msgBytes, prefix.length);
+    const signature = ed.sign(dataToSign, privateKey);
+    return { ...tx, signature };
+  }
+  async signMessage(message) {
+    const privateKey = this.getPrivateKey();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = ed.sign(messageBytes, privateKey);
+    return uint8ArrayToHex(signature);
+  }
+  async importFromMnemonic(mnemonic) {
+    const seed = bip392.mnemonicToSeedSync(mnemonic);
+    const privateKey = seed.slice(0, 32);
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    const walletDetails = {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: uint8ArrayToHex(privateKey),
+      mnemonic
+    };
+    setWarpWalletInConfig2(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async importFromPrivateKey(privateKey) {
+    const privateKeyBytes = hexToUint8Array(privateKey);
+    const publicKey = ed.getPublicKey(privateKeyBytes);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    const walletDetails = {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey,
+      mnemonic: null
+    };
+    setWarpWalletInConfig2(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async export() {
+    const privateKey = this.getPrivateKey();
+    const privateKeyHex = getWarpWalletPrivateKeyFromConfig2(this.config, this.chain.name);
+    const mnemonic = getWarpWalletMnemonicFromConfig2(this.config, this.chain.name);
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: privateKeyHex || null,
+      mnemonic: mnemonic || null
+    };
+  }
+  async generate() {
+    const privateKey = ed.utils.randomSecretKey();
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: uint8ArrayToHex(privateKey),
+      mnemonic: null
+    };
+  }
+  getPrivateKey() {
+    if (this.privateKey) return this.privateKey;
+    const privateKeyHex = getWarpWalletPrivateKeyFromConfig2(this.config, this.chain.name);
+    if (!privateKeyHex) throw new Error("No private key provided");
+    this.privateKey = hexToUint8Array(privateKeyHex);
+    return this.privateKey;
+  }
+};
+_PrivateKeyWalletProvider.PROVIDER_NAME = "privateKey";
+var PrivateKeyWalletProvider = _PrivateKeyWalletProvider;
+
+// src/providers/ReadOnlyWalletProvider.ts
+import { getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3 } from "@joai/warps";
+var ReadOnlyWalletProvider = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+  }
+  async getAddress() {
+    return getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+  }
+  async getPublicKey() {
+    return null;
+  }
+  async signTransaction(tx) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async signMessage(message) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async importFromMnemonic(mnemonic) {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async importFromPrivateKey(privateKey) {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async export() {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async generate() {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+};
+
+// src/WarpFastsetWallet.ts
+var WarpFastsetWallet = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.cachedAddress = null;
+    this.cachedPublicKey = null;
+    this.client = getConfiguredFastsetClient(this.config, this.chain);
+    this.walletProvider = this.createProvider();
+    this.initializeCache();
+  }
+  async signTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return await this.walletProvider.signTransaction(tx);
+  }
+  async signTransactions(txs) {
+    if (txs.length === 0) return [];
+    const signedTxs = [];
+    for (const tx of txs) {
+      signedTxs.push(await this.signTransaction(tx));
+    }
+    return signedTxs;
+  }
+  async signMessage(message) {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return await this.walletProvider.signMessage(message);
+  }
+  async sendTransaction(tx) {
+    const { signature, ...transactionWithoutSignature } = tx;
+    const _cert = await this.client.submitTransaction(transactionWithoutSignature, signature ?? null);
+    return "TODO";
+  }
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  }
+  async importFromMnemonic(mnemonic) {
+    const walletProvider = this.createProviderForOperation("mnemonic");
+    return await walletProvider.importFromMnemonic(mnemonic);
+  }
+  async importFromPrivateKey(privateKey) {
+    const walletProvider = this.createProviderForOperation("privateKey");
+    return await walletProvider.importFromPrivateKey(privateKey);
+  }
+  async export(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return await walletProvider.export();
+  }
+  async generate(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return await walletProvider.generate();
+  }
+  getAddress() {
+    return this.cachedAddress;
+  }
+  getPublicKey() {
+    return this.cachedPublicKey;
+  }
+  createProvider() {
+    const wallet = this.config.user?.wallets?.[this.chain.name];
+    if (!wallet) return null;
+    if (typeof wallet === "string") return new ReadOnlyWalletProvider(this.config, this.chain);
+    return this.createProviderForOperation(wallet.provider);
+  }
+  initializeCache() {
+    initializeWalletCache(this.walletProvider).then((cache) => {
+      this.cachedAddress = cache.address;
+      this.cachedPublicKey = cache.publicKey;
+    });
+  }
+  createProviderForOperation(provider) {
+    const customWalletProviders = this.config.walletProviders?.[this.chain.name];
+    const providerFactory = customWalletProviders?.[provider];
+    if (providerFactory) {
+      const walletProvider = providerFactory(this.config, this.chain);
+      if (!walletProvider) throw new Error(`Custom wallet provider factory returned null for ${provider}`);
+      return walletProvider;
+    }
+    if (provider === "privateKey") return new PrivateKeyWalletProvider(this.config, this.chain);
+    if (provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain);
+    throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
+  }
+};
+
+// src/main.ts
+var NativeTokenSet = {
+  chain: WarpChainName.Fastset,
+  identifier: "SET",
+  name: "SET",
+  symbol: "SET",
+  decimals: 0,
+  logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/set-black.svg"
+};
+function createFastsetAdapter(chainName, chainInfos) {
+  return (config, fallback) => {
+    const chainInfo = chainInfos[config.env];
+    if (!chainInfo) throw new Error(`FastsetAdapter: chain info not found for chain ${chainName}`);
+    if (!fallback) throw new Error("Fastset adapter requires a fallback adapter");
+    return {
+      chainInfo,
+      builder: () => fallback.builder(),
+      executor: new WarpFastsetExecutor(config, chainInfo),
+      output: new WarpFastsetOutput(config, chainInfo),
+      serializer: new WarpFastsetSerializer(),
+      registry: fallback.registry,
+      explorer: new WarpFastsetExplorer(chainInfo, config),
+      abiBuilder: () => fallback.abiBuilder(),
+      brandBuilder: () => fallback.brandBuilder(),
+      dataLoader: new WarpFastsetDataLoader(config, chainInfo),
+      wallet: new WarpFastsetWallet(config, chainInfo)
+    };
+  };
+}
+var FastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, {
+  mainnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet",
+    chainId: "1",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/fastset-black.svg",
+    nativeToken: NativeTokenSet
+  },
+  testnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet Testnet",
+    chainId: "testnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/fastset-black.svg",
+    nativeToken: NativeTokenSet
+  },
+  devnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet Devnet",
+    chainId: "devnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/fastset-black.svg",
+    nativeToken: NativeTokenSet
+  }
+});
+export {
+  FastsetAdapter,
+  NativeTokenSet,
+  WarpFastsetExecutor,
+  WarpFastsetWallet
+};
+/*! Bundled license information:
+
+@scure/base/lib/esm/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=index.mjs.map