@vleap/warps-adapter-fastset 0.1.0-alpha.8 → 0.1.0-beta.39

package/dist/index.js

@@ -1,8 +1,11 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,387 +18,1720 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Address: () => Address,
-  Amount: () => Amount,
-  Bytes32: () => Bytes32,
-  ClaimType: () => ClaimType,
-  FastsetClient: () => FastsetClient,
-  Nonce: () => Nonce,
-  PublicKey: () => PublicKey,
-  Transaction: () => Transaction,
-  Transfer: () => Transfer,
-  UserData: () => UserData,
-  WarpFastsetConstants: () => WarpFastsetConstants,
+  NativeTokenSet: () => NativeTokenSet,
   WarpFastsetExecutor: () => WarpFastsetExecutor,
-  WarpFastsetExplorer: () => WarpFastsetExplorer,
-  WarpFastsetResults: () => WarpFastsetResults,
-  WarpFastsetSerializer: () => WarpFastsetSerializer,
-  decimalToHex: () => decimalToHex,
-  fromBase64: () => fromBase64,
-  getFastsetAdapter: () => getFastsetAdapter,
-  hexToDecimal: () => hexToDecimal2,
-  isValidFastsetAddress: () => isValidFastsetAddress,
-  normalizeAmount: () => normalizeAmount,
-  toBase64String: () => toBase64String,
-  toHexString: () => toHexString,
-  validateAmount: () => validateAmount,
-  validatePrivateKey: () => validatePrivateKey,
-  validatePublicKey: () => validatePublicKey
+  WarpFastsetWallet: () => WarpFastsetWallet,
+  getFastsetAdapter: () => getFastsetAdapter
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/constants.ts
-var WarpFastsetConstants = {
-  Pi: {
-    Identifier: "PI",
-    DisplayName: "Pi",
-    Decimals: 18
-  },
-  GasLimit: {
-    Default: 21e3,
-    ContractCall: 1e5,
-    ContractDeploy: 5e5,
-    Transfer: 21e3,
-    Approve: 46e3,
-    Swap: 2e5
-  },
-  GasPrice: {
-    Default: "20000000000",
-    // 20 gwei
-    Low: "10000000000",
-    // 10 gwei
-    Medium: "20000000000",
-    // 20 gwei
-    High: "50000000000"
-    // 50 gwei
-  },
-  Validation: {
-    AddressLength: 42,
-    HexPrefix: "0x",
-    MinGasLimit: 21e3,
-    MaxGasLimit: 3e7
-  },
-  Timeouts: {
-    DefaultRpcTimeout: 3e4,
-    // 30 seconds
-    GasEstimationTimeout: 1e4,
-    // 10 seconds
-    QueryTimeout: 15e3
-    // 15 seconds
+// src/main.ts
+var import_warps6 = require("@vleap/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"));
+}
+function stringToUint8Array(str) {
+  return new Uint8Array(Buffer.from(str, "utf8"));
+}
+
+// src/helpers/general.ts
+var import_warps = require("@vleap/warps");
+
+// src/sdk/FastsetClient.ts
+var bech32 = __toESM(require("bech32"), 1);
+
+// ../../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");
 
-// src/WarpFastsetDataLoader.ts
-var WarpFastsetDataLoader = class {
-  constructor(config, chain) {
-    this.config = config;
-    this.chain = chain;
+// ../../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));
   }
-  async getAccount(address) {
-    return {
-      address,
-      balance: BigInt(0)
-      // TODO: Implement actual balance fetching from Fastset API
-    };
+  let output = "";
+  for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.slice(i, i + CHUNK_SIZE);
+    output += String.fromCharCode(...chunk);
   }
-  async getAccountAssets(address) {
-    return [];
+  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;
   }
 };
 
-// src/WarpFastsetExecutor.ts
-var import_warps2 = require("@vleap/warps");
+// ../../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");
+  }
+}
 
-// src/config.ts
-var FASTSET_CHAIN_CONFIGS = {
-  fastset: {
-    mainnet: {
-      apiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "https://explorer.fastset.com",
-      chainId: "1",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
-    },
-    testnet: {
-      apiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "https://testnet-explorer.fastset.com",
-      chainId: "11155111",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
-    },
-    devnet: {
-      apiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "http://localhost:4000",
-      chainId: "1337",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
+// ../../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 = 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));
   }
 };
-var DEFAULT_CHAIN = "fastset";
-var getFastsetChainConfig = (chain = DEFAULT_CHAIN, env) => {
-  const chainConfigs = FASTSET_CHAIN_CONFIGS[chain];
-  if (!chainConfigs) {
-    throw new Error(`Unsupported Fastset chain: ${chain}`);
+_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;
   }
-  const config = chainConfigs[env];
-  if (!config) {
-    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
+  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}`);
+        }
+      }
+    });
   }
-  return config;
 };
-var getFastsetApiUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getFastsetChainConfig(chain, env).apiUrl;
+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 getFastsetProxyUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getFastsetChainConfig(chain, env).proxyUrl;
+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}`);
+        }
+      }
+    });
+  }
 };
 
-// src/sdk/FastsetClient.ts
-var import_ed25519 = require("@noble/ed25519");
+// ../../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
-var import_bcs = require("@mysten/bcs");
 BigInt.prototype.toJSON = function() {
   return Number(this);
 };
-var Bytes32 = import_bcs.bcs.fixedArray(32, import_bcs.bcs.u8());
+var Bytes32 = bcs.fixedArray(32, bcs.u8());
+var Bytes64 = bcs.fixedArray(64, bcs.u8());
 var PublicKey = Bytes32;
-var Address = import_bcs.bcs.enum("Address", {
+var Signature = Bytes64;
+var Address = bcs.enum("Address", {
   External: PublicKey,
   FastSet: PublicKey
 });
-var Amount = import_bcs.bcs.u256().transform({
+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 UserData = import_bcs.bcs.option(Bytes32);
-var Nonce = import_bcs.bcs.u64();
-var Transfer = import_bcs.bcs.struct("Transfer", {
-  recipient: Address,
+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 ClaimType = import_bcs.bcs.enum("ClaimType", {
-  Transfer
+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 Transaction = import_bcs.bcs.struct("Transaction", {
+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: import_bcs.bcs.u128(),
+  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(config) {
-    this.config = config;
+  constructor(proxyUrl) {
+    this.proxyUrl = proxyUrl;
   }
-  async getAccountInfo(address) {
-    try {
-      const response = await this.requestValidator("set_getAccountInfo", {
-        address: Array.from(address)
-      });
-      if (response.error) {
-        return null;
-      }
-      return response.result;
-    } catch (error) {
-      return null;
-    }
+  async request(url, method, params) {
+    const request = this.buildJsonRpcRequest(id++, method, params);
+    const headers = { "Content-Type": "application/json" };
+    const body = this.jsonSerialize(request);
+    const response = await fetch(url, { method: "POST", headers, body });
+    const json = await response.json();
+    return json;
   }
-  async getNextNonce(senderAddress) {
-    const accountInfo = await this.getAccountInfo(senderAddress);
-    return accountInfo?.next_nonce ?? 0;
+  buildJsonRpcRequest(id2, method, params) {
+    return { jsonrpc: "2.0", id: id2, method, params };
   }
-  async fundFromFaucet(request) {
-    const response = await this.requestProxy("faucetDrip", {
-      recipient: Array.from(request.recipient),
-      amount: request.amount
+  jsonSerialize(data) {
+    return JSON.stringify(data, (k, v) => {
+      if (v instanceof Uint8Array) {
+        return Array.from(v);
+      }
+      return v;
     });
-    if (response.error) {
-      throw new Error(`Faucet request failed: ${response.error.message}`);
+  }
+  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));
     }
-    return response.result;
   }
-  async submitTransaction(request) {
-    const response = await this.requestValidator("set_submitTransaction", {
-      transaction: this.serializeTransaction(request.transaction),
-      signature: Array.from(request.signature)
-    });
-    if (response.error) {
-      throw new Error(`Transaction submission failed: ${response.error.message}`);
+  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));
     }
-    const result = response.result;
-    return {
-      transaction_hash: new Uint8Array(result.transaction_hash),
-      validator: new Uint8Array(result.validator),
-      signature: new Uint8Array(result.signature)
-    };
   }
-  async submitCertificate(request) {
-    const response = await this.requestValidator("set_submitTransactionCertificate", {
-      transaction: this.serializeTransaction(request.transaction),
-      signature: Array.from(request.signature),
-      validator_signatures: request.validator_signatures.map(([validator, signature]) => [Array.from(validator), Array.from(signature)])
-    });
-    if (response.error) {
-      throw new Error(`Certificate submission failed: ${response.error.message}`);
-    }
-  }
-  async executeTransfer(senderPrivateKey, recipient, amount, userData) {
-    const senderPublicKey = await (0, import_ed25519.getPublicKey)(senderPrivateKey);
-    const nonce = await this.getNextNonce(senderPublicKey);
-    const transaction = {
-      sender: senderPublicKey,
-      nonce,
-      timestamp_nanos: BigInt(Date.now()) * 1000000n,
-      claim: {
-        Transfer: {
-          recipient: { FastSet: recipient },
-          amount,
-          user_data: userData ?? null
-        }
-      }
-    };
-    const signature = await this.signTransaction(transaction, senderPrivateKey);
-    const submitResponse = await this.submitTransaction({
-      transaction,
-      signature
-    });
-    await this.submitCertificate({
-      transaction,
-      signature,
-      validator_signatures: [[submitResponse.validator, submitResponse.signature]]
-    });
-    return submitResponse.transaction_hash;
+  static encodeBech32Address(publicKey) {
+    const words = bech32.bech32m.toWords(publicKey);
+    return bech32.bech32m.encode("set", words);
   }
-  async signTransaction(transaction, privateKey) {
-    const msg = Transaction.serialize(transaction);
-    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);
-    return (0, import_ed25519.sign)(dataToSign, privateKey);
+};
+
+// src/helpers/general.ts
+var getConfiguredFastsetClient = (config, chain2) => {
+  const providerConfig = (0, import_warps.getProviderConfig)(config, chain2.name, config.env, chain2.defaultApiUrl);
+  return new FastsetClient(providerConfig.url);
+};
+
+// src/tokens/fastset.ts
+var FastsetTokens = [
+  {
+    chain: "fastset",
+    identifier: "08413efc81f99e5b8e03b852b3756674083110c6b65e6b7836b39a26e3908d3c",
+    name: "Ethereum",
+    symbol: "ETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png",
+    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://assets.coingecko.com/coins/images/4128/small/solana.png",
+    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
   }
-  serializeTransaction(transaction) {
-    return JSON.stringify(transaction, this.jsonReplacer);
+];
+
+// 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 requestValidator(method, params) {
-    return this.request(this.config.validatorUrl, method, params);
+  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 requestProxy(method, params) {
-    return this.request(this.config.proxyUrl, method, params);
+  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 request(url, method, params) {
-    const request = {
-      jsonrpc: "2.0",
-      id: 1,
-      method,
-      params
-    };
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(request, this.jsonReplacer)
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP request failed: ${response.statusText}`);
+  async getAsset(identifier) {
+    if (identifier === this.chain.nativeToken.identifier) {
+      return this.chain.nativeToken;
+    }
+    const assetInfo = await this.getAssetInfo(identifier);
+    if (!assetInfo) {
+      return null;
     }
-    return response.json();
+    return {
+      chain: this.chain.name,
+      identifier,
+      symbol: assetInfo.symbol,
+      name: assetInfo.name,
+      decimals: assetInfo.decimals,
+      logoUrl: assetInfo.logoUrl || null,
+      amount: 0n
+    };
+  }
+  async getAction(identifier, awaitCompleted = false) {
+    return null;
   }
-  jsonReplacer(key, value) {
-    if (value instanceof Uint8Array) {
-      return Array.from(value);
+  async getAccountActions(address, options) {
+    return [];
+  }
+  async getAssetInfo(identifier) {
+    const knownToken = findKnownTokenById(identifier, this.config.env) || findKnownTokenBySymbol(identifier, this.config.env);
+    if (knownToken) {
+      return knownToken;
     }
-    return value;
+    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/sdk/utils.ts
-var import_bcs2 = require("@mysten/bcs");
-function isValidFastsetAddress(address) {
-  if (typeof address !== "string" || address.length === 0) {
-    return false;
+// src/WarpFastsetExecutor.ts
+var import_warps2 = require("@vleap/warps");
+var WarpFastsetExecutor = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.client = getConfiguredFastsetClient(this.config, this.chain);
   }
-  if (address.startsWith("fs") || address.startsWith("pi")) {
-    return true;
+  async createTransaction(executable) {
+    const action = (0, import_warps2.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})`);
   }
-  try {
-    const decoded = fromBase64(address);
-    return decoded.length === 32;
-  } catch {
-    return false;
+  async createTransferTransaction(executable) {
+    if (!executable.destination) throw new Error("WarpFastsetExecutor: createTransfer - destination not set");
+    const userWallet = (0, import_warps2.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)");
+    }
   }
-}
-function fromBase64(base64) {
-  return new Uint8Array(Buffer.from(base64, "base64"));
-}
-function toBase64String(bytes) {
-  return (0, import_bcs2.toB64)(bytes);
-}
-function toHexString(bytes) {
-  return (0, import_bcs2.toHEX)(bytes);
-}
-function hexToDecimal2(hex) {
-  return BigInt(`0x${hex}`).toString();
-}
-function decimalToHex(decimal) {
-  return BigInt(decimal).toString(16);
-}
-function validateAmount(amount) {
-  try {
-    const bigInt = BigInt(amount);
-    return bigInt >= 0;
-  } catch {
-    return false;
+  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";
   }
-}
-function normalizeAmount(amount) {
-  try {
-    const bigInt = BigInt(amount);
-    return bigInt.toString(16);
-  } catch {
-    throw new Error(`Invalid amount format: ${amount}`);
+  getAccountUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
   }
-}
-function validatePrivateKey(privateKey) {
-  try {
-    const key = typeof privateKey === "string" ? fromBase64(privateKey) : privateKey;
-    return key.length === 32;
-  } catch {
-    return false;
+  getTransactionUrl(hash2) {
+    return `${this.explorerUrl}/txs/${HEX_PREFIX}${hash2}`;
   }
-}
-function validatePublicKey(publicKey) {
-  try {
-    const key = typeof publicKey === "string" ? fromBase64(publicKey) : publicKey;
-    return key.length === 32;
-  } catch {
-    return false;
+  getAssetUrl(identifier) {
+    return `${this.explorerUrl}/asset/${HEX_PREFIX}${identifier}`;
   }
-}
+  getContractUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
+  }
+};
+
+// src/WarpFastsetOutput.ts
+var import_warps4 = require("@vleap/warps");
 
 // src/WarpFastsetSerializer.ts
-var import_warps = require("@vleap/warps");
+var import_warps3 = require("@vleap/warps");
 var WarpFastsetSerializer = class {
   constructor() {
-    this.coreSerializer = new import_warps.WarpSerializer();
+    this.coreSerializer = new import_warps3.WarpSerializer();
   }
   typedToString(value) {
     if (typeof value === "string") {
@@ -408,7 +1744,7 @@ var WarpFastsetSerializer = class {
       return `boolean:${value}`;
     }
     if (typeof value === "bigint") {
-      return `bigint:${value.toString()}`;
+      return `biguint:${value.toString()}`;
     }
     if (Array.isArray(value)) {
       const items = value.map((item) => this.typedToString(item)).join(",");
@@ -433,7 +1769,7 @@ var WarpFastsetSerializer = class {
       return ["boolean", value];
     }
     if (typeof value === "bigint") {
-      return ["bigint", value];
+      return ["biguint", value.toString()];
     }
     return ["string", String(value)];
   }
@@ -445,8 +1781,12 @@ var WarpFastsetSerializer = class {
         return Number(value);
       case "boolean":
         return Boolean(value);
-      case "bigint":
+      case "biguint":
         return BigInt(value);
+      case "address":
+        return String(value);
+      case "hex":
+        return String(value);
       default:
         return String(value);
     }
@@ -459,8 +1799,12 @@ var WarpFastsetSerializer = class {
         return "number";
       case "boolean":
         return "boolean";
-      case "bigint":
-        return "bigint";
+      case "biguint":
+        return "biguint";
+      case "address":
+        return "address";
+      case "hex":
+        return "hex";
       default:
         return "string";
     }
@@ -479,7 +1823,7 @@ var WarpFastsetSerializer = class {
         return Number(stringValue);
       case "boolean":
         return stringValue === "true";
-      case "bigint":
+      case "biguint":
         return BigInt(stringValue);
       case "array":
         return stringValue.split(",").map((item) => this.stringToTyped(item));
@@ -493,361 +1837,1190 @@ var WarpFastsetSerializer = class {
   }
 };
 
-// src/WarpFastsetExecutor.ts
-var WarpFastsetExecutor = class {
-  constructor(config) {
+// src/WarpFastsetOutput.ts
+var WarpFastsetOutput = class {
+  constructor(config, chain2) {
     this.config = config;
+    this.chain = chain2;
     this.serializer = new WarpFastsetSerializer();
-    this.fastsetClient = new FastsetClient({
-      validatorUrl: getFastsetApiUrl(this.config.env, "fastset"),
-      proxyUrl: getFastsetProxyUrl(this.config.env, "fastset")
-    });
   }
-  async createTransaction(executable) {
-    const action = (0, import_warps2.getWarpActionByIndex)(executable.warp, executable.action);
-    switch (action.type) {
-      case "transfer":
-        return this.createTransferTransaction(executable);
-      case "contract":
-        return this.createContractCallTransaction(executable);
-      case "query":
-        throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeQuery instead");
-      case "collect":
-        throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeCollect instead");
-      default:
-        throw new Error(`WarpFastsetExecutor: Invalid action type (${action.type})`);
-    }
+  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: (0, import_warps4.getWarpWalletAddressFromConfig)(this.config, this.chain.name),
+      txHash: transactionHash,
+      tx,
+      next: null,
+      values: { string: stringValues, native: rawValues },
+      output: {},
+      messages: {},
+      destination: null
+    };
   }
-  async createTransferTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
-    if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
-    if (!isValidFastsetAddress(executable.destination)) {
-      throw new Error(`WarpFastsetExecutor: Invalid destination address: ${executable.destination}`);
-    }
-    if (executable.value < 0) {
-      throw new Error(`WarpFastsetExecutor: Transfer value cannot be negative: ${executable.value}`);
+  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 };
+    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(import_warps4.WarpConstants.Transform.Prefix)) continue;
+      const currentActionIndex = (0, import_warps4.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;
+      }
     }
-    const recipientAddress = fromBase64(executable.destination);
-    const amount = normalizeAmount(executable.value.toString());
-    const userData = executable.data ? fromBase64(this.serializer.stringToTyped(executable.data)) : void 0;
     return {
-      type: "fastset-transfer",
-      recipient: recipientAddress,
-      amount,
-      userData,
-      chain: executable.chain
+      values,
+      output: await (0, import_warps4.evaluateOutputCommon)(
+        warp,
+        output,
+        actionIndex,
+        inputs,
+        this.serializer.coreSerializer,
+        this.config
+      )
     };
   }
-  async createContractCallTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
-    if (!userWallet) throw new Error("WarpFastsetExecutor: createContractCall - user address not set");
-    const action = (0, import_warps2.getWarpActionByIndex)(executable.warp, executable.action);
-    if (!action || !("func" in action) || !action.func) {
-      throw new Error("WarpFastsetExecutor: Contract action must have a function name");
-    }
-    if (!isValidFastsetAddress(executable.destination)) {
-      throw new Error(`WarpFastsetExecutor: Invalid contract address: ${executable.destination}`);
-    }
-    if (executable.value < 0) {
-      throw new Error(`WarpFastsetExecutor: Contract call value cannot be negative: ${executable.value}`);
-    }
-    try {
-      const contractAddress = fromBase64(executable.destination);
-      const encodedData = this.encodeFunctionData(action.func, executable.args);
-      return {
-        type: "fastset-contract-call",
-        contract: contractAddress,
-        function: action.func,
-        data: encodedData,
-        value: executable.value,
-        chain: executable.chain
-      };
-    } catch (error) {
-      throw new Error(`WarpFastsetExecutor: Failed to encode function data for ${action.func}: ${error}`);
-    }
+  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;
   }
-  async executeQuery(executable) {
-    const action = (0, import_warps2.getWarpActionByIndex)(executable.warp, executable.action);
-    if (action.type !== "query") {
-      throw new Error(`WarpFastsetExecutor: Invalid action type for executeQuery: ${action.type}`);
+  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
+var bip39 = __toESM(require("@scure/bip39"), 1);
+var import_warps5 = require("@vleap/warps");
+
+// ../../node_modules/@noble/ed25519/index.js
+var ed25519_exports = {};
+__export(ed25519_exports, {
+  Point: () => Point,
+  etc: () => etc,
+  getPublicKey: () => getPublicKey,
+  getPublicKeyAsync: () => getPublicKeyAsync,
+  hash: () => hash,
+  hashes: () => hashes,
+  keygen: () => keygen,
+  keygenAsync: () => keygenAsync,
+  sign: () => sign,
+  signAsync: () => signAsync,
+  utils: () => utils,
+  verify: () => verify,
+  verifyAsync: () => verifyAsync
+});
+var ed25519_CURVE = {
+  p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
+  n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
+  h: 8n,
+  a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
+  d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
+  Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
+  Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
+};
+var { p: P, n: N, Gx, Gy, a: _a, d: _d, h } = ed25519_CURVE;
+var L = 32;
+var L2 = 64;
+var captureTrace = (...args) => {
+  if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
+    Error.captureStackTrace(...args);
+  }
+};
+var err = (message = "") => {
+  const e = new Error(message);
+  captureTrace(e, err);
+  throw e;
+};
+var isBig = (n) => typeof n === "bigint";
+var isStr = (s) => typeof s === "string";
+var isBytes2 = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+var 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}`;
+    err(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+};
+var u8n = (len) => new Uint8Array(len);
+var u8fr = (buf) => Uint8Array.from(buf);
+var padh = (n, pad) => n.toString(16).padStart(pad, "0");
+var bytesToHex = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
+var C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+var _ch = (ch) => {
+  if (ch >= C._0 && ch <= C._9)
+    return ch - C._0;
+  if (ch >= C.A && ch <= C.F)
+    return ch - (C.A - 10);
+  if (ch >= C.a && ch <= C.f)
+    return ch - (C.a - 10);
+  return;
+};
+var hexToBytes = (hex) => {
+  const e = "hex invalid";
+  if (!isStr(hex))
+    return err(e);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    return err(e);
+  const array = u8n(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = _ch(hex.charCodeAt(hi));
+    const n2 = _ch(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0)
+      return err(e);
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+};
+var cr = () => globalThis?.crypto;
+var subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined, consider polyfill");
+var concatBytes = (...arrs) => {
+  const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0));
+  let pad = 0;
+  arrs.forEach((a) => {
+    r.set(a, pad);
+    pad += a.length;
+  });
+  return r;
+};
+var randomBytes = (len = L) => {
+  const c = cr();
+  return c.getRandomValues(u8n(len));
+};
+var big = BigInt;
+var assertRange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
+var M = (a, b = P) => {
+  const r = a % b;
+  return r >= 0n ? r : b + r;
+};
+var modN = (a) => M(a, N);
+var invert = (num, md) => {
+  if (num === 0n || md <= 0n)
+    err("no inverse n=" + num + " mod=" + md);
+  let a = M(num, md), b = md, x = 0n, y = 1n, u = 1n, v = 0n;
+  while (a !== 0n) {
+    const q = b / a, r = b % a;
+    const m = x - u * q, n = y - v * q;
+    b = a, a = r, x = u, y = v, u = m, v = n;
+  }
+  return b === 1n ? M(x, md) : err("no inverse");
+};
+var callHash = (name) => {
+  const fn = hashes[name];
+  if (typeof fn !== "function")
+    err("hashes." + name + " not set");
+  return fn;
+};
+var hash = (msg) => callHash("sha512")(msg);
+var apoint = (p) => p instanceof Point ? p : err("Point expected");
+var B256 = 2n ** 256n;
+var _Point = class _Point {
+  constructor(X, Y, Z, T) {
+    __publicField(this, "X");
+    __publicField(this, "Y");
+    __publicField(this, "Z");
+    __publicField(this, "T");
+    const max = B256;
+    this.X = assertRange(X, 0n, max);
+    this.Y = assertRange(Y, 0n, max);
+    this.Z = assertRange(Z, 1n, max);
+    this.T = assertRange(T, 0n, max);
+    Object.freeze(this);
+  }
+  static CURVE() {
+    return ed25519_CURVE;
+  }
+  static fromAffine(p) {
+    return new _Point(p.x, p.y, 1n, M(p.x * p.y));
+  }
+  /** RFC8032 5.1.3: Uint8Array to Point. */
+  static fromBytes(hex, zip215 = false) {
+    const d = _d;
+    const normed = u8fr(abytes(hex, L));
+    const lastByte = hex[31];
+    normed[31] = lastByte & ~128;
+    const y = bytesToNumLE(normed);
+    const max = zip215 ? B256 : P;
+    assertRange(y, 0n, max);
+    const y2 = M(y * y);
+    const u = M(y2 - 1n);
+    const v = M(d * y2 + 1n);
+    let { isValid, value: x } = uvRatio(u, v);
+    if (!isValid)
+      err("bad point: y not sqrt");
+    const isXOdd = (x & 1n) === 1n;
+    const isLastByteOdd = (lastByte & 128) !== 0;
+    if (!zip215 && x === 0n && isLastByteOdd)
+      err("bad point: x==0, isLastByteOdd");
+    if (isLastByteOdd !== isXOdd)
+      x = M(-x);
+    return new _Point(x, y, 1n, M(x * y));
+  }
+  static fromHex(hex, zip215) {
+    return _Point.fromBytes(hexToBytes(hex), zip215);
+  }
+  get x() {
+    return this.toAffine().x;
+  }
+  get y() {
+    return this.toAffine().y;
+  }
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const a = _a;
+    const d = _d;
+    const p = this;
+    if (p.is0())
+      return err("bad point: ZERO");
+    const { X, Y, Z, T } = p;
+    const X2 = M(X * X);
+    const Y2 = M(Y * Y);
+    const Z2 = M(Z * Z);
+    const Z4 = M(Z2 * Z2);
+    const aX2 = M(X2 * a);
+    const left = M(Z2 * M(aX2 + Y2));
+    const right = M(Z4 + M(d * M(X2 * Y2)));
+    if (left !== right)
+      return err("bad point: equation left != right (1)");
+    const XY = M(X * Y);
+    const ZT = M(Z * T);
+    if (XY !== ZT)
+      return err("bad point: equation left != right (2)");
+    return this;
+  }
+  /** Equality check: compare points P&Q. */
+  equals(other) {
+    const { X: X1, Y: Y1, Z: Z1 } = this;
+    const { X: X2, Y: Y2, Z: Z2 } = apoint(other);
+    const X1Z2 = M(X1 * Z2);
+    const X2Z1 = M(X2 * Z1);
+    const Y1Z2 = M(Y1 * Z2);
+    const Y2Z1 = M(Y2 * Z1);
+    return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+  }
+  is0() {
+    return this.equals(I);
+  }
+  /** Flip point over y coordinate. */
+  negate() {
+    return new _Point(M(-this.X), this.Y, this.Z, M(-this.T));
+  }
+  /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+  double() {
+    const { X: X1, Y: Y1, Z: Z1 } = this;
+    const a = _a;
+    const A = M(X1 * X1);
+    const B = M(Y1 * Y1);
+    const C2 = M(2n * M(Z1 * Z1));
+    const D = M(a * A);
+    const x1y1 = X1 + Y1;
+    const E = M(M(x1y1 * x1y1) - A - B);
+    const G2 = D + B;
+    const F = G2 - C2;
+    const H = D - B;
+    const X3 = M(E * F);
+    const Y3 = M(G2 * H);
+    const T3 = M(E * H);
+    const Z3 = M(F * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
+  add(other) {
+    const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
+    const { X: X2, Y: Y2, Z: Z2, T: T2 } = apoint(other);
+    const a = _a;
+    const d = _d;
+    const A = M(X1 * X2);
+    const B = M(Y1 * Y2);
+    const C2 = M(T1 * d * T2);
+    const D = M(Z1 * Z2);
+    const E = M((X1 + Y1) * (X2 + Y2) - A - B);
+    const F = M(D - C2);
+    const G2 = M(D + C2);
+    const H = M(B - a * A);
+    const X3 = M(E * F);
+    const Y3 = M(G2 * H);
+    const T3 = M(E * H);
+    const Z3 = M(F * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  subtract(other) {
+    return this.add(apoint(other).negate());
+  }
+  /**
+   * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+   * Uses {@link wNAF} for base point.
+   * Uses fake point to mitigate side-channel leakage.
+   * @param n scalar by which point is multiplied
+   * @param safe safe mode guards against timing attacks; unsafe mode is faster
+   */
+  multiply(n, safe = true) {
+    if (!safe && (n === 0n || this.is0()))
+      return I;
+    assertRange(n, 1n, N);
+    if (n === 1n)
+      return this;
+    if (this.equals(G))
+      return wNAF(n).p;
+    let p = I;
+    let f = G;
+    for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
+      if (n & 1n)
+        p = p.add(d);
+      else if (safe)
+        f = f.add(d);
     }
-    if (!action.func) {
-      throw new Error("WarpFastsetExecutor: Query action must have a function name");
+    return p;
+  }
+  multiplyUnsafe(scalar) {
+    return this.multiply(scalar, false);
+  }
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { X, Y, Z } = this;
+    if (this.equals(I))
+      return { x: 0n, y: 1n };
+    const iz = invert(Z, P);
+    if (M(Z * iz) !== 1n)
+      err("invalid inverse");
+    const x = M(X * iz);
+    const y = M(Y * iz);
+    return { x, y };
+  }
+  toBytes() {
+    const { x, y } = this.assertValidity().toAffine();
+    const b = numTo32bLE(y);
+    b[31] |= x & 1n ? 128 : 0;
+    return b;
+  }
+  toHex() {
+    return bytesToHex(this.toBytes());
+  }
+  clearCofactor() {
+    return this.multiply(big(h), false);
+  }
+  isSmallOrder() {
+    return this.clearCofactor().is0();
+  }
+  isTorsionFree() {
+    let p = this.multiply(N / 2n, false).double();
+    if (N % 2n)
+      p = p.add(this);
+    return p.is0();
+  }
+};
+__publicField(_Point, "BASE");
+__publicField(_Point, "ZERO");
+var Point = _Point;
+var G = new Point(Gx, Gy, 1n, M(Gx * Gy));
+var I = new Point(0n, 1n, 1n, 0n);
+Point.BASE = G;
+Point.ZERO = I;
+var numTo32bLE = (num) => hexToBytes(padh(assertRange(num, 0n, B256), L2)).reverse();
+var bytesToNumLE = (b) => big("0x" + bytesToHex(u8fr(abytes(b)).reverse()));
+var pow2 = (x, power) => {
+  let r = x;
+  while (power-- > 0n) {
+    r *= r;
+    r %= P;
+  }
+  return r;
+};
+var pow_2_252_3 = (x) => {
+  const x2 = x * x % P;
+  const b2 = x2 * x % P;
+  const b4 = pow2(b2, 2n) * b2 % P;
+  const b5 = pow2(b4, 1n) * x % P;
+  const b10 = pow2(b5, 5n) * b5 % P;
+  const b20 = pow2(b10, 10n) * b10 % P;
+  const b40 = pow2(b20, 20n) * b20 % P;
+  const b80 = pow2(b40, 40n) * b40 % P;
+  const b160 = pow2(b80, 80n) * b80 % P;
+  const b240 = pow2(b160, 80n) * b80 % P;
+  const b250 = pow2(b240, 10n) * b10 % P;
+  const pow_p_5_8 = pow2(b250, 2n) * x % P;
+  return { pow_p_5_8, b2 };
+};
+var RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
+var uvRatio = (u, v) => {
+  const v3 = M(v * v * v);
+  const v7 = M(v3 * v3 * v);
+  const pow = pow_2_252_3(u * v7).pow_p_5_8;
+  let x = M(u * v3 * pow);
+  const vx2 = M(v * x * x);
+  const root1 = x;
+  const root2 = M(x * RM1);
+  const useRoot1 = vx2 === u;
+  const useRoot2 = vx2 === M(-u);
+  const noRoot = vx2 === M(-u * RM1);
+  if (useRoot1)
+    x = root1;
+  if (useRoot2 || noRoot)
+    x = root2;
+  if ((M(x) & 1n) === 1n)
+    x = M(-x);
+  return { isValid: useRoot1 || useRoot2, value: x };
+};
+var modL_LE = (hash2) => modN(bytesToNumLE(hash2));
+var sha512a = (...m) => hashes.sha512Async(concatBytes(...m));
+var sha512s = (...m) => callHash("sha512")(concatBytes(...m));
+var hash2extK = (hashed) => {
+  const head = hashed.slice(0, L);
+  head[0] &= 248;
+  head[31] &= 127;
+  head[31] |= 64;
+  const prefix = hashed.slice(L, L2);
+  const scalar = modL_LE(head);
+  const point = G.multiply(scalar);
+  const pointBytes = point.toBytes();
+  return { head, prefix, scalar, point, pointBytes };
+};
+var getExtendedPublicKeyAsync = (secretKey) => sha512a(abytes(secretKey, L)).then(hash2extK);
+var getExtendedPublicKey = (secretKey) => hash2extK(sha512s(abytes(secretKey, L)));
+var getPublicKeyAsync = (secretKey) => getExtendedPublicKeyAsync(secretKey).then((p) => p.pointBytes);
+var getPublicKey = (priv) => getExtendedPublicKey(priv).pointBytes;
+var hashFinishA = (res) => sha512a(res.hashable).then(res.finish);
+var hashFinishS = (res) => res.finish(sha512s(res.hashable));
+var _sign = (e, rBytes, msg) => {
+  const { pointBytes: P2, scalar: s } = e;
+  const r = modL_LE(rBytes);
+  const R = G.multiply(r).toBytes();
+  const hashable = concatBytes(R, P2, msg);
+  const finish = (hashed) => {
+    const S = modN(r + modL_LE(hashed) * s);
+    return abytes(concatBytes(R, numTo32bLE(S)), L2);
+  };
+  return { hashable, finish };
+};
+var signAsync = async (message, secretKey) => {
+  const m = abytes(message);
+  const e = await getExtendedPublicKeyAsync(secretKey);
+  const rBytes = await sha512a(e.prefix, m);
+  return hashFinishA(_sign(e, rBytes, m));
+};
+var sign = (message, secretKey) => {
+  const m = abytes(message);
+  const e = getExtendedPublicKey(secretKey);
+  const rBytes = sha512s(e.prefix, m);
+  return hashFinishS(_sign(e, rBytes, m));
+};
+var defaultVerifyOpts = { zip215: true };
+var _verify = (sig, msg, pub, opts = defaultVerifyOpts) => {
+  sig = abytes(sig, L2);
+  msg = abytes(msg);
+  pub = abytes(pub, L);
+  const { zip215 } = opts;
+  let A;
+  let R;
+  let s;
+  let SB;
+  let hashable = Uint8Array.of();
+  try {
+    A = Point.fromBytes(pub, zip215);
+    R = Point.fromBytes(sig.slice(0, L), zip215);
+    s = bytesToNumLE(sig.slice(L, L2));
+    SB = G.multiply(s, false);
+    hashable = concatBytes(R.toBytes(), A.toBytes(), msg);
+  } catch (error) {
+  }
+  const finish = (hashed) => {
+    if (SB == null)
+      return false;
+    if (!zip215 && A.isSmallOrder())
+      return false;
+    const k = modL_LE(hashed);
+    const RkA = R.add(A.multiply(k, false));
+    return RkA.add(SB.negate()).clearCofactor().is0();
+  };
+  return { hashable, finish };
+};
+var verifyAsync = async (signature, message, publicKey, opts = defaultVerifyOpts) => hashFinishA(_verify(signature, message, publicKey, opts));
+var verify = (signature, message, publicKey, opts = defaultVerifyOpts) => hashFinishS(_verify(signature, message, publicKey, opts));
+var etc = {
+  bytesToHex,
+  hexToBytes,
+  concatBytes,
+  mod: M,
+  invert,
+  randomBytes
+};
+var hashes = {
+  sha512Async: async (message) => {
+    const s = subtle();
+    const m = concatBytes(message);
+    return u8n(await s.digest("SHA-512", m.buffer));
+  },
+  sha512: void 0
+};
+var randomSecretKey = (seed = randomBytes(L)) => seed;
+var keygen = (seed) => {
+  const secretKey = randomSecretKey(seed);
+  const publicKey = getPublicKey(secretKey);
+  return { secretKey, publicKey };
+};
+var keygenAsync = async (seed) => {
+  const secretKey = randomSecretKey(seed);
+  const publicKey = await getPublicKeyAsync(secretKey);
+  return { secretKey, publicKey };
+};
+var utils = {
+  getExtendedPublicKeyAsync,
+  getExtendedPublicKey,
+  randomSecretKey
+};
+var W = 8;
+var scalarBits = 256;
+var pwindows = Math.ceil(scalarBits / W) + 1;
+var pwindowSize = 2 ** (W - 1);
+var precompute = () => {
+  const points = [];
+  let p = G;
+  let b = p;
+  for (let w = 0; w < pwindows; w++) {
+    b = p;
+    points.push(b);
+    for (let i = 1; i < pwindowSize; i++) {
+      b = b.add(p);
+      points.push(b);
     }
-    if (!isValidFastsetAddress(executable.destination)) {
-      throw new Error(`WarpFastsetExecutor: Invalid contract address for query: ${executable.destination}`);
+    p = b.double();
+  }
+  return points;
+};
+var Gpows = void 0;
+var ctneg = (cnd, p) => {
+  const n = p.negate();
+  return cnd ? n : p;
+};
+var wNAF = (n) => {
+  const comp = Gpows || (Gpows = precompute());
+  let p = I;
+  let f = G;
+  const pow_2_w = 2 ** W;
+  const maxNum = pow_2_w;
+  const mask = big(pow_2_w - 1);
+  const shiftBy = big(W);
+  for (let w = 0; w < pwindows; w++) {
+    let wbits = Number(n & mask);
+    n >>= shiftBy;
+    if (wbits > pwindowSize) {
+      wbits -= maxNum;
+      n += 1n;
     }
-    try {
-      const contractAddress = fromBase64(executable.destination);
-      const result = await this.executeFastsetQuery(contractAddress, action.func, executable.args);
-      return {
-        success: true,
-        result,
-        chain: executable.chain
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        chain: executable.chain
-      };
+    const off = w * pwindowSize;
+    const offF = off;
+    const offP = off + Math.abs(wbits) - 1;
+    const isEven = w % 2 !== 0;
+    const isNeg = wbits < 0;
+    if (wbits === 0) {
+      f = f.add(ctneg(isEven, comp[offF]));
+    } else {
+      p = p.add(ctneg(isNeg, comp[offP]));
     }
   }
-  async preprocessInput(chain, input, type, value) {
-    const typedValue = this.serializer.stringToTyped(value);
-    switch (type) {
-      case "address":
-        if (!isValidFastsetAddress(typedValue)) {
-          throw new Error(`Invalid Fastset address format: ${typedValue}`);
-        }
-        return typedValue;
-      case "hex":
-        const hexValue = typedValue.startsWith("0x") ? typedValue.slice(2) : typedValue;
-        if (!/^[0-9a-fA-F]+$/.test(hexValue)) {
-          throw new Error(`Invalid hex format: ${typedValue}`);
-        }
-        return typedValue;
-      case "number":
-        const numValue = Number(typedValue);
-        if (isNaN(numValue)) {
-          throw new Error(`Invalid number format: ${typedValue}`);
-        }
-        return numValue.toString();
-      case "biguint":
-        const bigIntValue = BigInt(typedValue);
-        if (bigIntValue < 0) {
-          throw new Error(`Negative value not allowed`);
-        }
-        return bigIntValue.toString();
-      default:
-        return String(typedValue);
-    }
+  if (n !== 0n)
+    err("invalid wnaf");
+  return { p, f };
+};
+
+// node_modules/@noble/hashes/utils.js
+function isBytes3(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes2(value, length, title = "") {
+  const bytes = isBytes3(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);
   }
-  encodeFunctionData(functionName, args) {
-    return JSON.stringify({
-      function: functionName,
-      arguments: args
-    });
+  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) {
+  abytes2(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
   }
-  async executeFastsetQuery(contractAddress, functionName, args) {
-    const response = await fetch(`${getFastsetApiUrl(this.config.env, "fastset")}/query`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        contract: Array.from(contractAddress),
-        function: functionName,
-        arguments: args
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Fastset query failed: ${response.statusText}`);
+}
+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);
+    abytes2(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;
+      }
     }
-    return response.json();
+    this.length += data.length;
+    this.roundClean();
+    return this;
   }
-  async signMessage(message, privateKey) {
-    throw new Error("Not implemented");
+  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);
   }
-  async executeTransfer(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
-    if (!userWallet) throw new Error("WarpFastsetExecutor: executeTransfer - user wallet not set");
-    const transaction = await this.createTransferTransaction(executable);
-    return {
-      success: true,
-      transaction,
-      chain: executable.chain.name,
-      message: "Transaction created successfully. Use executeTransferWithKey to execute with private key."
-    };
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
   }
-  async executeTransferWithKey(executable, privateKey) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
-    if (!userWallet) throw new Error("WarpFastsetExecutor: executeTransfer - user wallet not set");
-    const transaction = await this.createTransferTransaction(executable);
-    const privateKeyBytes = fromBase64(privateKey);
-    const transactionHash = await this.fastsetClient.executeTransfer(
-      privateKeyBytes,
-      transaction.recipient,
-      transaction.amount,
-      transaction.userData
-    );
-    return {
-      success: true,
-      transactionHash: Array.from(transactionHash),
-      chain: executable.chain.name
-    };
+  _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
+]);
 
-// src/WarpFastsetExplorer.ts
-var WarpFastsetExplorer = class {
-  constructor(chainInfo) {
-    this.chainInfo = chainInfo;
+// 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: h2, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h2, l];
   }
-  getAccountUrl(address) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/address/${address}`;
+  return [Ah, Al];
+}
+var shrSH = (h2, _l, s) => h2 >>> s;
+var shrSL = (h2, l, s) => h2 << 32 - s | l >>> s;
+var rotrSH = (h2, l, s) => h2 >>> s | l << 32 - s;
+var rotrSL = (h2, l, s) => h2 << 32 - s | l >>> s;
+var rotrBH = (h2, l, s) => h2 << 64 - s | l >>> s - 32;
+var rotrBL = (h2, l, s) => h2 >>> 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);
   }
-  getTransactionUrl(hash) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/tx/${hash}`;
+  // 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];
   }
-  getBlockUrl(blockNumber) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/block/${blockNumber}`;
+  // 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;
   }
-  getContractUrl(address) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/contract/${address}`;
+  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);
   }
-  getAssetUrl(identifier) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/token/${identifier}`;
+  roundClean() {
+    clean(SHA512_W_H, SHA512_W_L);
   }
-  getDefaultExplorerUrl() {
-    return `https://explorer.fastset.xyz`;
+  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/WarpFastsetResults.ts
-var import_warps3 = require("@vleap/warps");
-var WarpFastsetResults = class {
-  constructor(config) {
+// src/sdk/ed25519-setup.ts
+hashes.sha512 = sha512;
+
+// src/WarpFastsetWallet.ts
+var WarpFastsetWallet = class {
+  constructor(config, chain2) {
     this.config = config;
-    this.serializer = new WarpFastsetSerializer();
+    this.chain = chain2;
+    this.client = getConfiguredFastsetClient(this.config, this.chain);
   }
-  async getTransactionExecutionResults(warp, tx) {
-    const success = this.isTransactionSuccessful(tx);
-    const gasUsed = this.extractGasUsed(tx);
-    const gasPrice = this.extractGasPrice(tx);
-    const blockNumber = this.extractBlockNumber(tx);
-    const transactionHash = this.extractTransactionHash(tx);
-    const logs = this.extractLogs(tx);
-    return {
-      success,
-      warp,
-      action: 0,
-      user: this.config.user?.wallets?.fastset || null,
-      txHash: transactionHash,
-      next: null,
-      values: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
-      results: {},
-      messages: {}
-    };
+  async signTransaction(tx) {
+    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 privateKey = (0, import_warps5.getWarpWalletPrivateKeyFromConfig)(this.config, this.chain.name);
+    if (!privateKey) throw new Error("Wallet not initialized - no private key provided");
+    const privateKeyBytes = hexToUint8Array(privateKey);
+    const signature = ed25519_exports.sign(dataToSign, privateKeyBytes);
+    return { ...tx, signature };
   }
-  async extractQueryResults(warp, typedValues, actionIndex, inputs) {
-    const values = typedValues.map((t) => this.serializer.typedToString(t));
-    const valuesRaw = typedValues.map((t) => this.serializer.typedToNative(t)[1]);
-    let results = {};
-    if (!warp.results) return { values, results };
-    const getNestedValue = (path) => {
-      const indices = path.split(".").slice(1).map((i) => parseInt(i) - 1);
-      if (indices.length === 0) return void 0;
-      let value = valuesRaw[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.results)) {
-      if (path.startsWith(import_warps3.WarpConstants.Transform.Prefix)) continue;
-      const currentActionIndex = (0, import_warps3.parseResultsOutIndex)(path);
-      if (currentActionIndex !== null && currentActionIndex !== actionIndex) {
-        results[key] = null;
-        continue;
-      }
-      if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
-        results[key] = getNestedValue(path) || null;
-      } else {
-        results[key] = path;
-      }
-    }
-    return { values, results: await (0, import_warps3.evaluateResultsCommon)(warp, results, actionIndex, inputs) };
+  async signMessage(message) {
+    const messageBytes = stringToUint8Array(message);
+    const privateKey = (0, import_warps5.getWarpWalletPrivateKeyFromConfig)(this.config, this.chain.name);
+    if (!privateKey) throw new Error("Wallet not initialized - no private key provided");
+    const privateKeyBytes = hexToUint8Array(privateKey);
+    const signature = ed25519_exports.sign(messageBytes, privateKeyBytes);
+    return uint8ArrayToHex(signature);
   }
-  isTransactionSuccessful(tx) {
-    return tx.status === "success" || tx.status === 1 || tx.success === true;
+  async signTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.signTransaction(tx)));
   }
-  extractGasUsed(tx) {
-    return tx.gasUsed?.toString() || tx.gas_used?.toString() || "0";
+  async sendTransaction(tx) {
+    const { signature, ...transactionWithoutSignature } = tx;
+    const _cert = await this.client.submitTransaction(transactionWithoutSignature, signature ?? null);
+    return "TODO";
   }
-  extractGasPrice(tx) {
-    return tx.gasPrice?.toString() || tx.gas_price?.toString() || "0";
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
   }
-  extractBlockNumber(tx) {
-    return tx.blockNumber?.toString() || tx.block_number?.toString() || "0";
+  create(mnemonic) {
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const privateKey = seed.slice(0, 32);
+    const publicKey = ed25519_exports.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return { address, privateKey: uint8ArrayToHex(privateKey), mnemonic };
   }
-  extractTransactionHash(tx) {
-    return tx.hash || tx.transactionHash || tx.transaction_hash || "";
-  }
-  extractLogs(tx) {
-    const logs = tx.logs || tx.events || [];
-    return logs.map((log) => ({
-      address: log.address || log.contract,
-      topics: log.topics || log.topics || [],
-      data: log.data || log.payload || "",
-      blockNumber: log.blockNumber?.toString() || log.block_number?.toString() || "0",
-      transactionHash: log.transactionHash || log.transaction_hash || "",
-      index: log.index?.toString() || "0"
-    }));
+  generate() {
+    const privateKey = ed25519_exports.utils.randomSecretKey();
+    const publicKey = ed25519_exports.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return { address, privateKey: uint8ArrayToHex(privateKey), mnemonic: null };
+  }
+  getAddress() {
+    return (0, import_warps5.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
   }
 };
 
 // src/main.ts
-var ChainName = "fastset";
-var getFastsetAdapter = (config, fallback) => {
-  if (!fallback) throw new Error("Fastset adapter requires a fallback adapter");
-  const chainInfo = {
-    name: ChainName,
+var NativeTokenSet = {
+  chain: import_warps6.WarpChainName.Fastset,
+  identifier: "SET",
+  name: "SET",
+  symbol: "SET",
+  decimals: 0,
+  logoUrl: "https://vleap.ai/images/tokens/set.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 getFastsetAdapter = createFastsetAdapter(import_warps6.WarpChainName.Fastset, {
+  mainnet: {
+    name: import_warps6.WarpChainName.Fastset,
     displayName: "FastSet",
     chainId: "1",
-    blockTime: 100,
+    blockTime: 1e3,
     addressHrp: "set",
-    apiUrl: "TODO",
-    nativeToken: "SET"
-  };
-  return {
-    chain: ChainName,
-    chainInfo,
-    prefix: "fastset",
-    builder: () => fallback.builder(),
-    executor: new WarpFastsetExecutor(config),
-    results: new WarpFastsetResults(config),
-    serializer: new WarpFastsetSerializer(),
-    registry: fallback.registry,
-    explorer: new WarpFastsetExplorer(chainInfo),
-    abiBuilder: () => fallback.abiBuilder(),
-    brandBuilder: () => fallback.brandBuilder(),
-    dataLoader: new WarpFastsetDataLoader(config, chainInfo)
-  };
-};
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    logoUrl: "https://vleap.ai/images/chains/fastset.svg",
+    nativeToken: NativeTokenSet
+  },
+  testnet: {
+    name: import_warps6.WarpChainName.Fastset,
+    displayName: "FastSet Testnet",
+    chainId: "testnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    logoUrl: "https://vleap.ai/images/chains/fastset.svg",
+    nativeToken: NativeTokenSet
+  },
+  devnet: {
+    name: import_warps6.WarpChainName.Fastset,
+    displayName: "FastSet Devnet",
+    chainId: "devnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    logoUrl: "https://vleap.ai/images/chains/fastset.svg",
+    nativeToken: NativeTokenSet
+  }
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Address,
-  Amount,
-  Bytes32,
-  ClaimType,
-  FastsetClient,
-  Nonce,
-  PublicKey,
-  Transaction,
-  Transfer,
-  UserData,
-  WarpFastsetConstants,
+  NativeTokenSet,
   WarpFastsetExecutor,
-  WarpFastsetExplorer,
-  WarpFastsetResults,
-  WarpFastsetSerializer,
-  decimalToHex,
-  fromBase64,
-  getFastsetAdapter,
-  hexToDecimal,
-  isValidFastsetAddress,
-  normalizeAmount,
-  toBase64String,
-  toHexString,
-  validateAmount,
-  validatePrivateKey,
-  validatePublicKey
+  WarpFastsetWallet,
+  getFastsetAdapter
 });
+/*! Bundled license information:
+
+@scure/base/lib/esm/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/ed25519/index.js:
+  (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=index.js.map