@vleap/warps-adapter-fastset 0.1.0-alpha.24 → 0.1.0-alpha.26

package/dist/index.mjs

@@ -1,174 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/sdk/ed25519-setup.ts
-import * as ed from "@noble/ed25519";
-import { sha512 } from "@noble/hashes/sha512";
-var init_ed25519_setup = __esm({
-  "src/sdk/ed25519-setup.ts"() {
-    "use strict";
-    if (ed.etc) {
-      ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
-    }
-  }
-});
-
-// src/sdk/FastsetClient.ts
-import * as bech32 from "bech32";
-var Transaction, FastsetClient, Wallet;
-var init_FastsetClient = __esm({
-  "src/sdk/FastsetClient.ts"() {
-    "use strict";
-    init_ed25519_setup();
-    BigInt.prototype.toJSON = function() {
-      return Number(this);
-    };
-    Transaction = class {
-      constructor(sender, recipient, nonce, claim, timestamp = BigInt(Date.now()) * 1000000n) {
-        this.sender = sender;
-        this.recipient = recipient;
-        this.nonce = nonce;
-        this.claim = claim;
-        this.timestamp = timestamp;
-        if (claim?.Transfer?.amount?.startsWith("0x")) {
-          claim = { ...claim, Transfer: { ...claim.Transfer, amount: claim.Transfer.amount.slice(2) } };
-        }
-      }
-      toTransaction() {
-        return { sender: this.sender, recipient: this.recipient, nonce: this.nonce, timestamp_nanos: this.timestamp, claim: this.claim };
-      }
-      getRecipientAddress() {
-        return this.recipient;
-      }
-      getAmount() {
-        return this.claim?.Transfer?.amount || "";
-      }
-      getUserData() {
-        return this.claim?.Transfer?.user_data || null;
-      }
-    };
-    FastsetClient = class {
-      constructor(config, chain) {
-        this.proxyUrl = config && "proxyUrl" in config ? config.proxyUrl : config && chain ? chain.defaultApiUrl : "https://proxy.fastset.xyz";
-      }
-      async makeRequest(method, params = {}) {
-        const response = await fetch(this.proxyUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ jsonrpc: "2.0", method, params, id: Date.now() }, (k, v) => v instanceof Uint8Array ? Array.from(v) : v)
-        });
-        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-        const jsonResponse = await response.json();
-        if (jsonResponse.error) throw new Error(`JSON-RPC error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
-        return jsonResponse.result;
-      }
-      async getAccountInfo(address) {
-        return this.makeRequest("set_proxy_getAccountInfo", { address });
-      }
-      async getNextNonce(address) {
-        const addressBytes = typeof address === "string" ? this.addressToBytes(address) : address;
-        const accountInfo = await this.getAccountInfo(addressBytes);
-        return accountInfo.next_nonce;
-      }
-      async submitTransaction(transaction, signature) {
-        const signatureArray = Array.isArray(signature) ? signature : Array.from(signature);
-        const submitTxReq = {
-          transaction: {
-            sender: transaction.sender instanceof Uint8Array ? transaction.sender : new Uint8Array(transaction.sender),
-            recipient: transaction.recipient,
-            nonce: transaction.nonce,
-            timestamp_nanos: transaction.timestamp_nanos,
-            claim: transaction.claim
-          },
-          signature: new Uint8Array(signatureArray)
-        };
-        const response = await fetch(this.proxyUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(
-            { jsonrpc: "2.0", method: "set_proxy_submitTransaction", params: submitTxReq, id: 1 },
-            (k, v) => v instanceof Uint8Array ? Array.from(v) : v
-          )
-        });
-        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-        const jsonResponse = await response.json();
-        if (jsonResponse.error) throw new Error(`JSON-RPC error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
-        return jsonResponse.result;
-      }
-      async faucetDrip(recipient, amount) {
-        const recipientArray = Array.isArray(recipient) ? recipient : Array.from(recipient);
-        return this.makeRequest("set_proxy_faucetDrip", { recipient: recipientArray, amount });
-      }
-      addressToBytes(address) {
-        try {
-          const decoded = bech32.bech32m.decode(address);
-          return Array.from(bech32.bech32m.fromWords(decoded.words));
-        } catch {
-          const decoded = bech32.bech32.decode(address);
-          return Array.from(bech32.bech32.fromWords(decoded.words));
-        }
-      }
-      // Wallet utilities
-      generateNewWallet() {
-        const privateKey = ed.utils.randomPrivateKey();
-        return new Wallet(Buffer.from(privateKey).toString("hex"));
-      }
-      createWallet(privateKeyHex) {
-        return new Wallet(privateKeyHex);
-      }
-      static decodeBech32Address(address) {
-        try {
-          const decoded = bech32.bech32m.decode(address);
-          return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
-        } catch {
-          const decoded = bech32.bech32.decode(address);
-          return new Uint8Array(bech32.bech32.fromWords(decoded.words));
-        }
-      }
-      static encodeBech32Address(publicKey) {
-        const words = bech32.bech32m.toWords(publicKey);
-        return bech32.bech32m.encode("set", words);
-      }
-    };
-    Wallet = class {
-      constructor(privateKeyHex) {
-        this.privateKey = new Uint8Array(Buffer.from(privateKeyHex.replace(/^0x/, ""), "hex"));
-        this.publicKey = ed.getPublicKey(this.privateKey);
-      }
-      toBech32() {
-        return bech32.bech32m.encode("set", bech32.bech32m.toWords(this.publicKey));
-      }
-      signTransactionRaw(data) {
-        return ed.sign(data, this.privateKey);
-      }
-      getPrivateKey() {
-        return this.privateKey;
-      }
-    };
-  }
-});
-
-// src/sdk/index.ts
-var sdk_exports = {};
-__export(sdk_exports, {
-  FastsetClient: () => FastsetClient,
-  Transaction: () => Transaction,
-  Wallet: () => Wallet
-});
-var init_sdk = __esm({
-  "src/sdk/index.ts"() {
-    "use strict";
-    init_FastsetClient();
-  }
-});
-
 // src/main.ts
 import { WarpChainName } from "@vleap/warps";
 
@@ -189,34 +18,97 @@ function stringToUint8Array(str) {
 }
 
 // src/helpers/general.ts
-init_sdk();
 import { getProviderUrl } from "@vleap/warps";
-var getConfiguredFastsetClient = (config, chain) => {
-  const proxyUrl = getProviderUrl(config, chain.name, config.env, chain.defaultApiUrl);
-  return new FastsetClient({ proxyUrl });
+
+// src/sdk/FastsetClient.ts
+import * as bech32 from "bech32";
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
+var id = 0;
+var FastsetClient = class {
+  constructor(proxyUrl) {
+    this.proxyUrl = proxyUrl;
+  }
+  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;
+  }
+  buildJsonRpcRequest(id2, method, params) {
+    return { jsonrpc: "2.0", id: id2, method, params };
+  }
+  jsonSerialize(data) {
+    return JSON.stringify(data, (k, v) => {
+      if (v instanceof Uint8Array) {
+        return Array.from(v);
+      }
+      return v;
+    });
+  }
+  async getAccountInfo(address) {
+    return this.request(this.proxyUrl, "set_proxy_getAccountInfo", { address });
+  }
+  async getNextNonce(address) {
+    const addressBytes = typeof address === "string" ? this.addressToBytes(address) : address;
+    const accountInfoRes = await this.getAccountInfo(addressBytes);
+    return accountInfoRes.result?.next_nonce ?? 0;
+  }
+  addressToBytes(address) {
+    try {
+      const decoded = bech32.bech32m.decode(address);
+      return Array.from(bech32.bech32m.fromWords(decoded.words));
+    } catch {
+      const decoded = bech32.bech32.decode(address);
+      return Array.from(bech32.bech32.fromWords(decoded.words));
+    }
+  }
+  static decodeBech32Address(address) {
+    try {
+      const decoded = bech32.bech32m.decode(address);
+      return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+    } catch {
+      const decoded = bech32.bech32.decode(address);
+      return new Uint8Array(bech32.bech32.fromWords(decoded.words));
+    }
+  }
+  static encodeBech32Address(publicKey) {
+    const words = bech32.bech32m.toWords(publicKey);
+    return bech32.bech32m.encode("set", words);
+  }
+};
+
+// src/helpers/general.ts
+var getConfiguredFastsetClient = (config, chain2) => {
+  const proxyUrl = getProviderUrl(config, chain2.name, config.env, chain2.defaultApiUrl);
+  return new FastsetClient(proxyUrl);
 };
 
 // src/WarpFastsetDataLoader.ts
 var WarpFastsetDataLoader = class {
-  constructor(config, chain) {
+  constructor(config, chain2) {
     this.config = config;
-    this.chain = chain;
-    this.client = getConfiguredFastsetClient(config, chain);
+    this.chain = chain2;
+    this.client = getConfiguredFastsetClient(config, chain2);
   }
   async getAccount(address) {
     const addressBytes = this.addressToBytes(address);
     const accountInfo = await this.client.getAccountInfo(addressBytes);
-    return { chain: this.chain.name, address, balance: BigInt(parseInt(accountInfo.balance, 16)) };
+    return { chain: this.chain.name, address, balance: BigInt(parseInt(accountInfo.result?.balance ?? "0", 16)) };
   }
   async getAccountAssets(address) {
     const addressBytes = this.addressToBytes(address);
     const accountInfo = await this.client.getAccountInfo(addressBytes);
     const assets = [];
-    const balance = BigInt(parseInt(accountInfo.balance, 16));
+    console.log("accountInfo", accountInfo);
+    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.token_balance) {
+    for (const [tokenId, tokenBalance] of accountInfo.result?.token_balance ?? []) {
       const amount = BigInt(parseInt(tokenBalance, 16));
       if (amount > 0n) {
         const tokenInfo = await this.client.getTokenInfo([tokenId]);
@@ -274,16 +166,15 @@ var WarpFastsetDataLoader = class {
 };
 
 // src/WarpFastsetExecutor.ts
-init_sdk();
 import {
   getWarpActionByIndex,
   getWarpWalletAddressFromConfig
 } from "@vleap/warps";
 var WarpFastsetExecutor = class {
-  constructor(config, chain) {
+  constructor(config, chain2) {
     this.config = config;
-    this.chain = chain;
-    this.fastsetClient = new FastsetClient({ proxyUrl: "https://proxy.fastset.xyz" });
+    this.chain = chain2;
+    this.client = getConfiguredFastsetClient(this.config, this.chain);
   }
   async createTransaction(executable) {
     const action = getWarpActionByIndex(executable.warp, executable.action);
@@ -292,99 +183,30 @@ var WarpFastsetExecutor = class {
     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 (unknown)`);
+    throw new Error(`WarpFastsetExecutor: Invalid action type (${action.type})`);
   }
   async createTransferTransaction(executable) {
     const userWallet = getWarpWalletAddressFromConfig(this.config, executable.chain.name);
     if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
-    const senderAddress = FastsetClient.decodeBech32Address(userWallet);
-    let recipientAddress;
-    try {
-      recipientAddress = FastsetClient.decodeBech32Address(executable.destination);
-    } catch (error) {
-      throw new Error(`WarpFastsetExecutor: Invalid destination address: ${executable.destination}`);
-    }
-    const nonce = await this.fastsetClient.getNextNonce(userWallet);
-    const transferValue = executable.transfers?.[0]?.amount || executable.value;
-    if (transferValue < 0) throw new Error(`WarpFastsetExecutor: Transfer value cannot be negative: ${transferValue}`);
-    const amount = "0x" + transferValue.toString(16);
-    const userData = executable.data ? this.fromBase64(executable.data) : null;
-    const claim = { Transfer: { amount, user_data: userData } };
-    return new Transaction(senderAddress, { FastSet: recipientAddress }, nonce, claim);
-  }
-  async createContractCallTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
-    if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
-    const action = getWarpActionByIndex(executable.warp, executable.action);
-    if (!action || !("func" in action) || !action.func) throw new Error("WarpFastsetExecutor: Contract action must have a function name");
-    let contractAddress;
-    try {
-      contractAddress = this.fromBase64(executable.destination);
-    } catch (error) {
-      throw new Error(`WarpFastsetExecutor: Invalid contract address: ${executable.destination}`);
-    }
+    const senderPubKey = FastsetClient.decodeBech32Address(userWallet);
+    const recipientPubKey = FastsetClient.decodeBech32Address(executable.destination);
+    const nonce = await this.client.getNextNonce(userWallet);
+    const nativeAmountInTransfers = executable.transfers.find((transfer) => transfer.identifier === this.chain.nativeToken?.identifier)?.amount || 0n;
+    const nativeAmountTotal = nativeAmountInTransfers + executable.value;
+    const amountHex = BigInt(nativeAmountTotal).toString(16);
     return {
-      type: "fastset-contract-call",
-      contract: contractAddress,
-      function: action.func,
-      data: JSON.stringify({ function: action.func, arguments: executable.args }),
-      value: executable.value,
-      chain: executable.chain
-    };
-  }
-  async executeQuery(executable) {
-    const action = getWarpActionByIndex(executable.warp, executable.action);
-    if (action.type !== "query") throw new Error(`WarpFastsetExecutor: Invalid action type for executeQuery: ${action.type}`);
-    if (!action.func) throw new Error("WarpFastsetExecutor: Query action must have a function name");
-    try {
-      const result = await this.executeFastsetQuery(this.fromBase64(executable.destination), 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 };
-    }
-  }
-  async executeTransfer(executable) {
-    const transaction = await this.createTransferTransaction(executable);
-    return { success: true, transaction, chain: executable.chain.name };
-  }
-  async executeTransferWithKey(executable, privateKey) {
-    const transaction = await this.createTransferTransaction(executable);
-    const privateKeyBytes = this.fromBase64(privateKey);
-    const transactionData = {
-      sender: privateKeyBytes.slice(0, 32),
-      recipient: transaction.getRecipientAddress(),
-      nonce: await this.fastsetClient.getNextNonce(FastsetClient.encodeBech32Address(privateKeyBytes.slice(0, 32))),
+      sender: senderPubKey,
+      recipient: { FastSet: recipientPubKey },
+      nonce,
       timestamp_nanos: BigInt(Date.now()) * 1000000n,
-      claim: { Transfer: { amount: transaction.getAmount(), user_data: transaction.getUserData() } }
+      claim: { Transfer: { amount: amountHex, user_data: null } }
     };
-    const signature = await this.signTransaction(transactionData, privateKeyBytes);
-    const result = await this.fastsetClient.submitTransaction(transactionData, signature);
-    return { success: true, result, message: "Transaction submitted successfully", chain: executable.chain.name };
-  }
-  async signTransaction(transaction, privateKey) {
-    const wallet = new (await Promise.resolve().then(() => (init_sdk(), sdk_exports))).Wallet(Buffer.from(privateKey).toString("hex"));
-    return wallet.signTransactionRaw(this.serializeTransaction(transaction));
-  }
-  serializeTransaction(tx) {
-    const serialized = JSON.stringify(tx, (k, v) => v instanceof Uint8Array ? Array.from(v) : v);
-    return new TextEncoder().encode(serialized);
-  }
-  async executeFastsetQuery(contractAddress, functionName, args) {
-    const response = await fetch("https://proxy.fastset.xyz", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        method: "set_proxy_query",
-        params: { contract: Array.from(contractAddress), function: functionName, arguments: args },
-        id: 1
-      })
-    });
-    if (!response.ok) throw new Error(`Fastset query failed: ${response.statusText}`);
-    return response.json();
   }
-  fromBase64(base64) {
-    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  async createContractCallTransaction(executable) {
+    throw new Error("WarpFastsetExecutor: Not implemented");
+  }
+  async executeQuery(executable) {
+    throw new Error("WarpFastsetExecutor: Not implemented");
   }
 };
 
@@ -531,9 +353,9 @@ var WarpFastsetSerializer = class {
 
 // src/WarpFastsetResults.ts
 var WarpFastsetResults = class {
-  constructor(config, chain) {
+  constructor(config, chain2) {
     this.config = config;
-    this.chain = chain;
+    this.chain = chain2;
     this.serializer = new WarpFastsetSerializer();
   }
   async getTransactionExecutionResults(warp, tx) {
@@ -617,71 +439,1824 @@ var WarpFastsetResults = class {
 // src/WarpFastsetWallet.ts
 import * as bip39 from "@scure/bip39";
 import {
+  getProviderUrl as getProviderUrl2,
   getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3,
   getWarpWalletPrivateKeyFromConfig
 } from "@vleap/warps";
-init_sdk();
-init_ed25519_setup();
+
+// src/sdk/ed25519-setup.ts
+import * as ed from "@noble/ed25519";
+
+// ../../node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+var Hash = class {
+};
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../../node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n2 = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n2 & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE ? 4 : 0;
+  const l = isLE ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+var HashMD = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    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);
+    data = toBytes(data);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, 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 should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]);
+
+// ../../node_modules/@noble/hashes/esm/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var shrSH = (h, _l, s) => h >>> s;
+var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+// ../../node_modules/@noble/hashes/esm/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 SHA512 = class extends HashMD {
+  constructor(outputLen = 64) {
+    super(128, outputLen, 16, false);
+    this.Ah = SHA512_IV[0] | 0;
+    this.Al = SHA512_IV[1] | 0;
+    this.Bh = SHA512_IV[2] | 0;
+    this.Bl = SHA512_IV[3] | 0;
+    this.Ch = SHA512_IV[4] | 0;
+    this.Cl = SHA512_IV[5] | 0;
+    this.Dh = SHA512_IV[6] | 0;
+    this.Dl = SHA512_IV[7] | 0;
+    this.Eh = SHA512_IV[8] | 0;
+    this.El = SHA512_IV[9] | 0;
+    this.Fh = SHA512_IV[10] | 0;
+    this.Fl = SHA512_IV[11] | 0;
+    this.Gh = SHA512_IV[12] | 0;
+    this.Gl = SHA512_IV[13] | 0;
+    this.Hh = SHA512_IV[14] | 0;
+    this.Hl = SHA512_IV[15] | 0;
+  }
+  // prettier-ignore
+  get() {
+    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+  }
+  // prettier-ignore
+  set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+    this.Ah = Ah | 0;
+    this.Al = Al | 0;
+    this.Bh = Bh | 0;
+    this.Bl = Bl | 0;
+    this.Ch = Ch | 0;
+    this.Cl = Cl | 0;
+    this.Dh = Dh | 0;
+    this.Dl = Dl | 0;
+    this.Eh = Eh | 0;
+    this.El = El | 0;
+    this.Fh = Fh | 0;
+    this.Fl = Fl | 0;
+    this.Gh = Gh | 0;
+    this.Gl = Gl | 0;
+    this.Hh = Hh | 0;
+    this.Hl = Hl | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4) {
+      SHA512_W_H[i] = view.getUint32(offset);
+      SHA512_W_L[i] = view.getUint32(offset += 4);
+    }
+    for (let i = 16; i < 80; i++) {
+      const W15h = SHA512_W_H[i - 15] | 0;
+      const W15l = SHA512_W_L[i - 15] | 0;
+      const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+      const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+      const W2h = SHA512_W_H[i - 2] | 0;
+      const W2l = SHA512_W_L[i - 2] | 0;
+      const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+      const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+      const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+      const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+      SHA512_W_H[i] = SUMh | 0;
+      SHA512_W_L[i] = SUMl | 0;
+    }
+    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    for (let i = 0; i < 80; i++) {
+      const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+      const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+      const CHIh = Eh & Fh ^ ~Eh & Gh;
+      const CHIl = El & Fl ^ ~El & Gl;
+      const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+      const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+      const T1l = T1ll | 0;
+      const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+      const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+      const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+      const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+      Hh = Gh | 0;
+      Hl = Gl | 0;
+      Gh = Fh | 0;
+      Gl = Fl | 0;
+      Fh = Eh | 0;
+      Fl = El | 0;
+      ({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+      Dh = Ch | 0;
+      Dl = Cl | 0;
+      Ch = Bh | 0;
+      Cl = Bl | 0;
+      Bh = Ah | 0;
+      Bl = Al | 0;
+      const All = add3L(T1l, sigma0l, MAJl);
+      Ah = add3H(All, T1h, sigma0h, MAJh);
+      Al = All | 0;
+    }
+    ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+    ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+    ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+    ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+    ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+    ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+    ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+    ({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+  }
+  roundClean() {
+    clean(SHA512_W_H, SHA512_W_L);
+  }
+  destroy() {
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+};
+var sha512 = /* @__PURE__ */ createHasher(() => new SHA512());
+
+// ../../node_modules/@noble/hashes/esm/sha512.js
+var sha5122 = sha512;
+
+// src/sdk/ed25519-setup.ts
+ed.hashes.sha512 = sha5122;
+
+// ../../node_modules/@scure/base/lib/esm/index.js
+function isBytes2(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 (!isBytes2(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join(""));
+var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+
+// ../../node_modules/@mysten/utils/dist/esm/b58.js
+var toBase58 = (buffer) => base58.encode(buffer);
+var fromBase58 = (str) => base58.decode(str);
+
+// ../../node_modules/@mysten/utils/dist/esm/b64.js
+function fromBase64(base64String) {
+  return Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));
+}
+var CHUNK_SIZE = 8192;
+function toBase64(bytes) {
+  if (bytes.length < CHUNK_SIZE) {
+    return btoa(String.fromCharCode(...bytes));
+  }
+  let output = "";
+  for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.slice(i, i + CHUNK_SIZE);
+    output += String.fromCharCode(...chunk);
+  }
+  return btoa(output);
+}
+
+// ../../node_modules/@mysten/utils/dist/esm/hex.js
+function fromHex(hexStr) {
+  const normalized = hexStr.startsWith("0x") ? hexStr.slice(2) : hexStr;
+  const padded = normalized.length % 2 === 0 ? normalized : `0${normalized}`;
+  const intArr = padded.match(/[0-9a-fA-F]{2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
+  if (intArr.length !== padded.length / 2) {
+    throw new Error(`Invalid hex string ${hexStr}`);
+  }
+  return Uint8Array.from(intArr);
+}
+function toHex(bytes) {
+  return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+}
+
+// ../../node_modules/@mysten/bcs/dist/esm/uleb.js
+function ulebEncode(num) {
+  const arr = [];
+  let len = 0;
+  if (num === 0) {
+    return [0];
+  }
+  while (num > 0) {
+    arr[len] = num & 127;
+    if (num >>= 7) {
+      arr[len] |= 128;
+    }
+    len += 1;
+  }
+  return arr;
+}
+function ulebDecode(arr) {
+  let total = 0;
+  let shift = 0;
+  let len = 0;
+  while (true) {
+    const byte = arr[len];
+    len += 1;
+    total |= (byte & 127) << shift;
+    if ((byte & 128) === 0) {
+      break;
+    }
+    shift += 7;
+  }
+  return {
+    value: total,
+    length: len
+  };
+}
+
+// ../../node_modules/@mysten/bcs/dist/esm/reader.js
+var BcsReader = class {
+  /**
+   * @param {Uint8Array} data Data to use as a buffer.
+   */
+  constructor(data) {
+    this.bytePosition = 0;
+    this.dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  /**
+   * Shift current cursor position by `bytes`.
+   *
+   * @param {Number} bytes Number of bytes to
+   * @returns {this} Self for possible chaining.
+   */
+  shift(bytes) {
+    this.bytePosition += bytes;
+    return this;
+  }
+  /**
+   * Read U8 value from the buffer and shift cursor by 1.
+   * @returns
+   */
+  read8() {
+    const value = this.dataView.getUint8(this.bytePosition);
+    this.shift(1);
+    return value;
+  }
+  /**
+   * Read U16 value from the buffer and shift cursor by 2.
+   * @returns
+   */
+  read16() {
+    const value = this.dataView.getUint16(this.bytePosition, true);
+    this.shift(2);
+    return value;
+  }
+  /**
+   * Read U32 value from the buffer and shift cursor by 4.
+   * @returns
+   */
+  read32() {
+    const value = this.dataView.getUint32(this.bytePosition, true);
+    this.shift(4);
+    return value;
+  }
+  /**
+   * Read U64 value from the buffer and shift cursor by 8.
+   * @returns
+   */
+  read64() {
+    const value1 = this.read32();
+    const value2 = this.read32();
+    const result = value2.toString(16) + value1.toString(16).padStart(8, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+   * Read U128 value from the buffer and shift cursor by 16.
+   */
+  read128() {
+    const value1 = BigInt(this.read64());
+    const value2 = BigInt(this.read64());
+    const result = value2.toString(16) + value1.toString(16).padStart(16, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+   * Read U128 value from the buffer and shift cursor by 32.
+   * @returns
+   */
+  read256() {
+    const value1 = BigInt(this.read128());
+    const value2 = BigInt(this.read128());
+    const result = value2.toString(16) + value1.toString(16).padStart(32, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+   * Read `num` number of bytes from the buffer and shift cursor by `num`.
+   * @param num Number of bytes to read.
+   */
+  readBytes(num) {
+    const start = this.bytePosition + this.dataView.byteOffset;
+    const value = new Uint8Array(this.dataView.buffer, start, num);
+    this.shift(num);
+    return value;
+  }
+  /**
+   * Read ULEB value - an integer of varying size. Used for enum indexes and
+   * vector lengths.
+   * @returns {Number} The ULEB value.
+   */
+  readULEB() {
+    const start = this.bytePosition + this.dataView.byteOffset;
+    const buffer = new Uint8Array(this.dataView.buffer, start);
+    const { value, length } = ulebDecode(buffer);
+    this.shift(length);
+    return value;
+  }
+  /**
+   * Read a BCS vector: read a length and then apply function `cb` X times
+   * where X is the length of the vector, defined as ULEB in BCS bytes.
+   * @param cb Callback to process elements of vector.
+   * @returns {Array<Any>} Array of the resulting values, returned by callback.
+   */
+  readVec(cb) {
+    const length = this.readULEB();
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      result.push(cb(this, i, length));
+    }
+    return result;
+  }
+};
+
+// ../../node_modules/@mysten/bcs/dist/esm/utils.js
+function encodeStr(data, encoding) {
+  switch (encoding) {
+    case "base58":
+      return toBase58(data);
+    case "base64":
+      return toBase64(data);
+    case "hex":
+      return toHex(data);
+    default:
+      throw new Error("Unsupported encoding, supported values are: base64, hex");
+  }
+}
+
+// ../../node_modules/@mysten/bcs/dist/esm/writer.js
+var BcsWriter = class {
+  constructor({
+    initialSize = 1024,
+    maxSize = Infinity,
+    allocateSize = 1024
+  } = {}) {
+    this.bytePosition = 0;
+    this.size = initialSize;
+    this.maxSize = maxSize;
+    this.allocateSize = allocateSize;
+    this.dataView = new DataView(new ArrayBuffer(initialSize));
+  }
+  ensureSizeOrGrow(bytes) {
+    const requiredSize = this.bytePosition + bytes;
+    if (requiredSize > this.size) {
+      const nextSize = Math.min(this.maxSize, 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 U16 value into a buffer and shift cursor position by 2.
+   * @param {Number} value Value to write.
+   * @returns {this}
+   */
+  write16(value) {
+    this.ensureSizeOrGrow(2);
+    this.dataView.setUint16(this.bytePosition, Number(value), true);
+    return this.shift(2);
+  }
+  /**
+   * Write a U32 value into a buffer and shift cursor position by 4.
+   * @param {Number} value Value to write.
+   * @returns {this}
+   */
+  write32(value) {
+    this.ensureSizeOrGrow(4);
+    this.dataView.setUint32(this.bytePosition, Number(value), true);
+    return this.shift(4);
+  }
+  /**
+   * Write a U64 value into a buffer and shift cursor position by 8.
+   * @param {bigint} value Value to write.
+   * @returns {this}
+   */
+  write64(value) {
+    toLittleEndian(BigInt(value), 8).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+   * Write a U128 value into a buffer and shift cursor position by 16.
+   *
+   * @param {bigint} value Value to write.
+   * @returns {this}
+   */
+  write128(value) {
+    toLittleEndian(BigInt(value), 16).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+   * Write a U256 value into a buffer and shift cursor position by 16.
+   *
+   * @param {bigint} value Value to write.
+   * @returns {this}
+   */
+  write256(value) {
+    toLittleEndian(BigInt(value), 32).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+   * Write a ULEB value into a buffer and shift cursor position by number of bytes
+   * written.
+   * @param {Number} value Value to write.
+   * @returns {this}
+   */
+  writeULEB(value) {
+    ulebEncode(value).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+   * Write a vector into a buffer by first writing the vector length and then calling
+   * a callback on each passed value.
+   *
+   * @param {Array<Any>} vector Array of elements to write.
+   * @param {WriteVecCb} cb Callback to call on each element of the vector.
+   * @returns {this}
+   */
+  writeVec(vector2, cb) {
+    this.writeULEB(vector2.length);
+    Array.from(vector2).forEach((el, i) => cb(this, el, i, vector2.length));
+    return this;
+  }
+  /**
+   * Adds support for iterations over the object.
+   * @returns {Uint8Array}
+   */
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.bytePosition; i++) {
+      yield this.dataView.getUint8(i);
+    }
+    return this.toBytes();
+  }
+  /**
+   * Get underlying buffer taking only value bytes (in case initial buffer size was bigger).
+   * @returns {Uint8Array} Resulting bcs.
+   */
+  toBytes() {
+    return new Uint8Array(this.dataView.buffer.slice(0, this.bytePosition));
+  }
+  /**
+   * Represent data as 'hex' or 'base64'
+   * @param encoding Encoding to use: 'base64' or 'hex'
+   */
+  toString(encoding) {
+    return encodeStr(this.toBytes(), encoding);
+  }
+};
+function toLittleEndian(bigint, size) {
+  const result = new Uint8Array(size);
+  let i = 0;
+  while (bigint > 0) {
+    result[i] = Number(bigint % BigInt(256));
+    bigint = bigint / BigInt(256);
+    i += 1;
+  }
+  return result;
+}
+
+// ../../node_modules/@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: name2,
+    input,
+    output,
+    validate
+  }) {
+    return new _BcsType2({
+      name: name2 ?? 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));
+  }
+};
+_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: toBytes2,
+  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 = toBytes2(hex);
+      writer.writeULEB(bytes.length);
+      for (let i = 0; i < bytes.length; i++) {
+        writer.write8(bytes[i]);
+      }
+    },
+    serialize: (value) => {
+      const bytes = toBytes2(value);
+      const size = ulebEncode(bytes.length);
+      const result = new Uint8Array(size.length + bytes.length);
+      result.set(size, 0);
+      result.set(bytes, size.length);
+      return result;
+    },
+    validate: (value) => {
+      if (typeof value !== "string") {
+        throw new TypeError(`Invalid ${options.name} value: ${value}. Expected string`);
+      }
+      options.validate?.(value);
+    }
+  });
+}
+function lazyBcsType(cb) {
+  let lazyType = null;
+  function getType() {
+    if (!lazyType) {
+      lazyType = cb();
+    }
+    return lazyType;
+  }
+  return new BcsType({
+    name: "lazy",
+    read: (data) => getType().read(data),
+    serializedSize: (value) => getType().serializedSize(value),
+    write: (value, writer) => getType().write(value, writer),
+    serialize: (value, options) => getType().serialize(value, options).toBytes()
+  });
+}
+var BcsStruct = class extends BcsType {
+  constructor({ name: name2, fields, ...options }) {
+    const canonicalOrder = Object.entries(fields);
+    super({
+      name: name2,
+      serializedSize: (values) => {
+        let total = 0;
+        for (const [field, type] of canonicalOrder) {
+          const size = type.serializedSize(values[field]);
+          if (size == null) {
+            return null;
+          }
+          total += size;
+        }
+        return total;
+      },
+      read: (reader) => {
+        const result = {};
+        for (const [field, type] of canonicalOrder) {
+          result[field] = type.read(reader);
+        }
+        return result;
+      },
+      write: (value, writer) => {
+        for (const [field, type] of canonicalOrder) {
+          type.write(value[field], writer);
+        }
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "object" || value == null) {
+          throw new TypeError(`Expected object, found ${typeof value}`);
+        }
+      }
+    });
+  }
+};
+var BcsEnum = class extends BcsType {
+  constructor({ fields, ...options }) {
+    const canonicalOrder = Object.entries(fields);
+    super({
+      read: (reader) => {
+        const index = reader.readULEB();
+        const enumEntry = canonicalOrder[index];
+        if (!enumEntry) {
+          throw new TypeError(`Unknown value ${index} for enum ${name}`);
+        }
+        const [kind, type] = enumEntry;
+        return {
+          [kind]: type?.read(reader) ?? true,
+          $kind: kind
+        };
+      },
+      write: (value, writer) => {
+        const [name2, val] = Object.entries(value).filter(
+          ([name3]) => Object.hasOwn(fields, name3)
+        )[0];
+        for (let i = 0; i < canonicalOrder.length; i++) {
+          const [optionName, optionType] = canonicalOrder[i];
+          if (optionName === name2) {
+            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 ${name}}`
+          );
+        }
+        const [variant] = keys;
+        if (!Object.hasOwn(fields, variant)) {
+          throw new TypeError(`Invalid enum variant ${variant}`);
+        }
+      }
+    });
+  }
+};
+var BcsTuple = class extends BcsType {
+  constructor({ fields, name: name2, ...options }) {
+    super({
+      name: name2 ?? `(${fields.map((t) => t.name).join(", ")})`,
+      serializedSize: (values) => {
+        let total = 0;
+        for (let i = 0; i < fields.length; i++) {
+          const size = fields[i].serializedSize(values[i]);
+          if (size == null) {
+            return null;
+          }
+          total += size;
+        }
+        return total;
+      },
+      read: (reader) => {
+        const result = [];
+        for (const field of fields) {
+          result.push(field.read(reader));
+        }
+        return result;
+      },
+      write: (value, writer) => {
+        for (let i = 0; i < fields.length; i++) {
+          fields[i].write(value[i], writer);
+        }
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (!Array.isArray(value)) {
+          throw new TypeError(`Expected array, found ${typeof value}`);
+        }
+        if (value.length !== fields.length) {
+          throw new TypeError(`Expected array of length ${fields.length}, found ${value.length}`);
+        }
+      }
+    });
+  }
+};
+
+// ../../node_modules/@mysten/bcs/dist/esm/bcs.js
+function fixedArray(size, type, options) {
+  return new BcsType({
+    read: (reader) => {
+      const result = new Array(size);
+      for (let i = 0; i < size; i++) {
+        result[i] = type.read(reader);
+      }
+      return result;
+    },
+    write: (value, writer) => {
+      for (const item of value) {
+        type.write(item, writer);
+      }
+    },
+    ...options,
+    name: options?.name ?? `${type.name}[${size}]`,
+    validate: (value) => {
+      options?.validate?.(value);
+      if (!value || typeof value !== "object" || !("length" in value)) {
+        throw new TypeError(`Expected array, found ${typeof value}`);
+      }
+      if (value.length !== size) {
+        throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+      }
+    }
+  });
+}
+function option(type) {
+  return bcs.enum(`Option<${type.name}>`, {
+    None: null,
+    Some: type
+  }).transform({
+    input: (value) => {
+      if (value == null) {
+        return { None: true };
+      }
+      return { Some: value };
+    },
+    output: (value) => {
+      if (value.$kind === "Some") {
+        return value.Some;
+      }
+      return null;
+    }
+  });
+}
+function vector(type, options) {
+  return new BcsType({
+    read: (reader) => {
+      const length = reader.readULEB();
+      const result = new Array(length);
+      for (let i = 0; i < length; i++) {
+        result[i] = type.read(reader);
+      }
+      return result;
+    },
+    write: (value, writer) => {
+      writer.writeULEB(value.length);
+      for (const item of value) {
+        type.write(item, writer);
+      }
+    },
+    ...options,
+    name: options?.name ?? `vector<${type.name}>`,
+    validate: (value) => {
+      options?.validate?.(value);
+      if (!value || typeof value !== "object" || !("length" in value)) {
+        throw new TypeError(`Expected array, found ${typeof value}`);
+      }
+    }
+  });
+}
+function map(keyType, valueType) {
+  return bcs.vector(bcs.tuple([keyType, valueType])).transform({
+    name: `Map<${keyType.name}, ${valueType.name}>`,
+    input: (value) => {
+      return [...value.entries()];
+    },
+    output: (value) => {
+      const result = /* @__PURE__ */ new Map();
+      for (const [key, val] of value) {
+        result.set(key, val);
+      }
+      return result;
+    }
+  });
+}
+var bcs = {
+  /**
+   * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
+   * @example
+   * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
+   */
+  u8(options) {
+    return uIntBcsType({
+      readMethod: "read8",
+      writeMethod: "write8",
+      size: 1,
+      maxValue: 2 ** 8 - 1,
+      ...options,
+      name: options?.name ?? "u8"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.
+   * @example
+   * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
+   */
+  u16(options) {
+    return uIntBcsType({
+      readMethod: "read16",
+      writeMethod: "write16",
+      size: 2,
+      maxValue: 2 ** 16 - 1,
+      ...options,
+      name: options?.name ?? "u16"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.
+   * @example
+   * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
+   */
+  u32(options) {
+    return uIntBcsType({
+      readMethod: "read32",
+      writeMethod: "write32",
+      size: 4,
+      maxValue: 2 ** 32 - 1,
+      ...options,
+      name: options?.name ?? "u32"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.
+   * @example
+   * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
+   */
+  u64(options) {
+    return bigUIntBcsType({
+      readMethod: "read64",
+      writeMethod: "write64",
+      size: 8,
+      maxValue: 2n ** 64n - 1n,
+      ...options,
+      name: options?.name ?? "u64"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.
+   * @example
+   * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+   */
+  u128(options) {
+    return bigUIntBcsType({
+      readMethod: "read128",
+      writeMethod: "write128",
+      size: 16,
+      maxValue: 2n ** 128n - 1n,
+      ...options,
+      name: options?.name ?? "u128"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.
+   * @example
+   * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+   */
+  u256(options) {
+    return bigUIntBcsType({
+      readMethod: "read256",
+      writeMethod: "write256",
+      size: 32,
+      maxValue: 2n ** 256n - 1n,
+      ...options,
+      name: options?.name ?? "u256"
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write boolean values.
+   * @example
+   * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
+   */
+  bool(options) {
+    return fixedSizeBcsType({
+      size: 1,
+      read: (reader) => reader.read8() === 1,
+      write: (value, writer) => writer.write8(value ? 1 : 0),
+      ...options,
+      name: options?.name ?? "bool",
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "boolean") {
+          throw new TypeError(`Expected boolean, found ${typeof value}`);
+        }
+      }
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write unsigned LEB encoded integers
+   * @example
+   *
+   */
+  uleb128(options) {
+    return dynamicSizeBcsType({
+      read: (reader) => reader.readULEB(),
+      serialize: (value) => {
+        return Uint8Array.from(ulebEncode(value));
+      },
+      ...options,
+      name: options?.name ?? "uleb128"
+    });
+  },
+  /**
+   * Creates a BcsType representing a fixed length byte array
+   * @param size The number of bytes this types represents
+   * @example
+   * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
+   */
+  bytes(size, options) {
+    return fixedSizeBcsType({
+      size,
+      read: (reader) => reader.readBytes(size),
+      write: (value, writer) => {
+        const array = new Uint8Array(value);
+        for (let i = 0; i < size; i++) {
+          writer.write8(array[i] ?? 0);
+        }
+      },
+      ...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);
+        for (let i = 0; i < array.length; i++) {
+          writer.write8(array[i] ?? 0);
+        }
+      },
+      ...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(name2, fields, options) {
+    return new BcsStruct({
+      name: name2,
+      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(name2, fields, options) {
+    return new BcsEnum({
+      name: name2,
+      fields,
+      ...options
+    });
+  },
+  /**
+   * Creates a BcsType representing a map of a given key and value type
+   * @param keyType The BcsType of the key
+   * @param valueType The BcsType of the value
+   * @example
+   * const map = bcs.map(bcs.u8(), bcs.string())
+   * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
+   */
+  map,
+  /**
+   * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.
+   * @param cb A callback that returns the BcsType
+   */
+  lazy(cb) {
+    return lazyBcsType(cb);
+  }
+};
+
+// src/sdk/types.ts
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
+var Bytes32 = bcs.fixedArray(32, bcs.u8());
+var Bytes64 = bcs.fixedArray(64, bcs.u8());
+var PublicKey = Bytes32;
+var Signature = Bytes64;
+var Address = bcs.enum("Address", {
+  External: PublicKey,
+  FastSet: PublicKey
+});
+var Amount = bcs.u256().transform({
+  // CAUTION: When we build a transaction object, we must use a hex encoded string because the
+  // validator expects amounts to be in hex. However, bcs.u256() by default expects a decimal
+  // string. Therefore, we must transform the input amount from hex to decimal here.
+  input: (val) => hexToDecimal(val.toString()),
+  output: (value) => value
+});
+var Balance = bcs.string().transform({
+  input: (val) => val,
+  output: (value) => value
+});
+var UserData = bcs.option(Bytes32);
+var Nonce = bcs.u64();
+var Quorum = bcs.u64();
+var TokenId = Bytes32;
+var Transfer = bcs.struct("Transfer", {
+  amount: Amount,
+  user_data: UserData
+});
+var TokenTransfer = bcs.struct("TokenTransfer", {
+  token_id: TokenId,
+  amount: Amount,
+  user_data: UserData
+});
+var TokenCreation = bcs.struct("TokenCreation", {
+  token_name: bcs.string(),
+  decimals: bcs.u8(),
+  initial_amount: Amount,
+  mints: bcs.vector(PublicKey),
+  user_data: UserData
+});
+var AddressChange = bcs.enum("AddressChange", {
+  Add: PublicKey,
+  Remove: PublicKey
+});
+var TokenManagement = bcs.struct("TokenManagement", {
+  token_id: TokenId,
+  update_id: Nonce,
+  new_admin: bcs.option(PublicKey),
+  mints: bcs.vector(bcs.tuple([AddressChange, PublicKey])),
+  user_data: UserData
+});
+var Mint = bcs.struct("Mint", {
+  token_id: TokenId,
+  amount: Amount
+});
+var ClaimData = bcs.vector(bcs.u8());
+var ExternalClaimBody = bcs.struct("ExternalClaimBody", {
+  verifier_committee: bcs.vector(PublicKey),
+  verifier_quorum: Quorum,
+  claim_data: ClaimData
+});
+var ExternalClaim = bcs.struct("ExternalClaim", {
+  claim: ExternalClaimBody,
+  signatures: bcs.vector(bcs.tuple([PublicKey, Signature]))
+});
+var ClaimType = bcs.enum("ClaimType", {
+  Transfer,
+  TokenTransfer,
+  TokenCreation,
+  TokenManagement,
+  Mint,
+  ExternalClaim
+});
+var Transaction = bcs.struct("Transaction", {
+  sender: PublicKey,
+  recipient: Address,
+  nonce: Nonce,
+  timestamp_nanos: bcs.u128(),
+  claim: ClaimType
+});
+var SubmitTransactionResponse = bcs.struct("SubmitTransactionResponse", {
+  validator: PublicKey,
+  signature: Signature,
+  next_nonce: Nonce,
+  transaction_hash: bcs.vector(bcs.u8())
+});
+var TransactionEnvelope = bcs.struct("TransactionEnvelope", {
+  transaction: Transaction,
+  signature: Signature
+});
+var TransactionCertificate = bcs.struct("TransactionCertificate", {
+  envelope: TransactionEnvelope,
+  signatures: bcs.vector(bcs.tuple([PublicKey, Signature]))
+});
+function hexToDecimal(hex) {
+  return BigInt(`0x${hex}`).toString();
+}
+
+// src/WarpFastsetWallet.ts
 var WarpFastsetWallet = class {
-  constructor(config, chain) {
+  constructor(config, chain2) {
     this.config = config;
-    this.chain = chain;
-    this.wallet = null;
-    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (privateKey) {
-      this.wallet = new Wallet(privateKey);
-    }
+    this.chain = chain2;
     this.client = getConfiguredFastsetClient(this.config, this.chain);
+    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    if (!privateKey) throw new Error("Wallet not initialized - no private key provided");
+    this.privateKey = privateKey;
   }
   async signTransaction(tx) {
-    if (!this.wallet) throw new Error("Wallet not initialized");
-    const transaction = tx;
-    const serializedTx = this.serializeTransaction(transaction.toTransaction());
-    const signature = await ed.sign(serializedTx, this.wallet.getPrivateKey());
-    return Object.assign(transaction, { signature: uint8ArrayToHex(signature) });
+    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 privateKeyBytes = hexToUint8Array(this.privateKey);
+    const signature = ed.sign(dataToSign, privateKeyBytes);
+    return { ...tx, signature };
   }
   async signMessage(message) {
-    if (!this.wallet) throw new Error("Wallet not initialized");
     const messageBytes = stringToUint8Array(message);
-    const signature = await ed.sign(messageBytes, this.wallet.getPrivateKey());
+    const privateKeyBytes = hexToUint8Array(this.privateKey);
+    const signature = ed.sign(messageBytes, privateKeyBytes);
     return uint8ArrayToHex(signature);
   }
   async sendTransaction(tx) {
-    if (!this.wallet) throw new Error("Wallet not initialized");
-    const transaction = tx;
-    const fastsetTx = transaction.toTransaction();
-    const transactionData = {
-      sender: fastsetTx.sender,
-      recipient: fastsetTx.recipient,
-      nonce: fastsetTx.nonce,
-      timestamp_nanos: fastsetTx.timestamp_nanos,
-      claim: fastsetTx.claim
-    };
-    const signature = tx.signature ? hexToUint8Array(tx.signature) : await ed.sign(this.serializeTransaction(transactionData), this.wallet.getPrivateKey());
-    return await this.client.submitTransaction(transactionData, signature);
+    const { signature, ...transactionWithoutSignature } = tx;
+    const submitTxReq = { transaction: transactionWithoutSignature, signature };
+    const proxyUrl = getProviderUrl2(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    const response = await this.client.request(proxyUrl, "set_proxy_submitTransaction", submitTxReq);
+    if (response.error) throw new Error(`JSON-RPC error ${response.error.code}: ${response.error.message}`);
+    console.log("submitTransaction response", response.result);
+    return "TODO";
   }
   create(mnemonic) {
     const seed = bip39.mnemonicToSeedSync(mnemonic);
     const privateKey = seed.slice(0, 32);
-    const wallet = new Wallet(uint8ArrayToHex(privateKey));
-    return { address: wallet.toBech32(), privateKey: uint8ArrayToHex(wallet.getPrivateKey()), mnemonic };
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return { address, privateKey: uint8ArrayToHex(privateKey), mnemonic };
   }
   generate() {
     const privateKey = ed.utils.randomPrivateKey();
-    const wallet = new Wallet(uint8ArrayToHex(privateKey));
-    return { address: wallet.toBech32(), privateKey: uint8ArrayToHex(wallet.getPrivateKey()), mnemonic: null };
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return { address, privateKey: uint8ArrayToHex(privateKey), mnemonic: null };
   }
   getAddress() {
     return getWarpWalletAddressFromConfig3(this.config, this.chain.name);
   }
-  serializeTransaction(tx) {
-    const serialized = JSON.stringify(tx, (k, v) => {
-      if (v instanceof Uint8Array) return Array.from(v);
-      if (typeof v === "bigint") return v.toString();
-      return v;
-    });
-    return encoder.encode(serialized);
-  }
 };
 
 // src/main.ts
@@ -690,7 +2265,7 @@ var NativeTokenSet = {
   identifier: "SET",
   name: "SET",
   symbol: "SET",
-  decimals: 6,
+  decimals: 0,
   logoUrl: "https://vleap.ai/images/tokens/set.svg"
 };
 function createFastsetAdapter(chainName, chainPrefix, chainInfos) {
@@ -747,16 +2322,18 @@ var getFastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, "fastset", {
     nativeToken: NativeTokenSet
   }
 });
-
-// src/index.ts
-init_sdk();
 export {
-  FastsetClient,
   NativeTokenSet,
-  Transaction,
-  Wallet,
   WarpFastsetExecutor,
   WarpFastsetWallet,
   getFastsetAdapter
 };
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@scure/base/lib/esm/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=index.mjs.map