@naviprotocol/wallet-client 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1174 @@
+import { getFullnodeUrl as F, SuiClient as W } from "@mysten/sui/client";
+import _ from "mitt";
+import A from "axios";
+import { withSingleton as j, getCoins as K, mergeCoinsPTB as w, getPools as N, getPool as m, depositCoinPTB as q, withdrawCoinPTB as L, borrowCoinPTB as M, repayCoinPTB as $, getHealthFactor as G, liquidatePTB as H, getUserAvailableLendingRewards as O, getUserClaimedRewardHistory as J, claimLendingRewardsPTB as z, getPriceFeeds as D, filterPriceFeeds as Q, updateOraclePricesPTB as V, getLendingState as X, createAccountCapPTB as Y, withCache as k, parseTxValue as R } from "@naviprotocol/lending";
+import S, { BigNumber as x } from "bignumber.js";
+import { normalizeStructTag as P } from "@mysten/sui/utils";
+import { Transaction as d } from "@mysten/sui/transactions";
+import { generateRefId as Z, getQuote as ee, buildSwapPTBFromQuote as te } from "@naviprotocol/astros-aggregator-sdk";
+import { Signer as U } from "@mysten/sui/cryptography";
+const p = A.create({
+  timeout: 2e4
+});
+p.interceptors.response.use(
+  function(o) {
+    if (o.data.err)
+      throw new Error(o.data.err);
+    if (o.data.error)
+      throw new Error(o.data.error.message);
+    return o;
+  },
+  function(o) {
+    return Promise.reject(o);
+  }
+);
+class ae {
+  /**
+   * Creates a new custom transport instance
+   *
+   * @param rpcUrl - The RPC endpoint URL for the Sui node
+   */
+  constructor(e) {
+    this.requestId = 0, this.rpcUrl = e;
+  }
+  /**
+   * Makes an RPC request to the Sui node
+   *
+   * This method formats the request according to JSON-RPC 2.0 specification
+   * and sends it to the configured RPC endpoint.
+   *
+   * @param input - The transport request options containing method and parameters
+   * @returns Promise<T> - The response data from the RPC call
+   */
+  async request(e) {
+    return this.requestId += 1, (await p.post(this.rpcUrl, {
+      jsonrpc: "2.0",
+      id: this.requestId,
+      method: e.method,
+      params: e.params
+    })).data.result;
+  }
+  /**
+   * Subscribe to events (not implemented)
+   *
+   * This method is required by the SuiTransport interface but is not
+   * implemented in this custom transport. It throws an error if called.
+   *
+   * @returns Promise<() => Promise<boolean>> - Unsubscribe function
+   * @throws Error - Always throws "subscribe not implemented" error
+   */
+  async subscribe() {
+    throw new Error("subscribe not implemented.");
+  }
+}
+class T {
+  /**
+   * Gets the current configuration for this module
+   *
+   * This combines the default configuration with any user-provided overrides
+   * from the wallet client configuration.
+   *
+   * @returns The merged configuration for this module
+   */
+  get config() {
+    return this.walletClient ? this.walletClient.config(this.name) : this.defaultConfig;
+  }
+  /**
+   * Emits an event through the wallet client's event system
+   *
+   * @param event - The event name to emit
+   * @param data - The event data to emit
+   */
+  emit(e, a) {
+    var t;
+    (t = this.walletClient) == null || t.events.emit(e, a);
+  }
+  /**
+   * Installs this module into a wallet client
+   *
+   * This method is called by the wallet client during initialization
+   * to establish the connection between the module and the client.
+   *
+   * @param walletClient - The wallet client instance to install into
+   */
+  install(e) {
+    this.walletClient = e;
+  }
+  /**
+   * Uninstalls this module from the wallet client
+   *
+   * This method removes the reference to the wallet client,
+   * effectively disconnecting the module.
+   */
+  uninstall() {
+    this.walletClient = void 0;
+  }
+}
+class B {
+  /**
+   * Creates a new user portfolio
+   *
+   * @param coins - Array of coin objects or existing portfolio to copy from
+   */
+  constructor(e) {
+    if (e instanceof B)
+      this.balances = JSON.parse(JSON.stringify(e.balances));
+    else {
+      const a = {};
+      e == null || e.forEach((t) => {
+        const s = P(t.coinType);
+        let n = a[s];
+        n || (n = {
+          coinType: s,
+          amount: x(0),
+          coins: []
+        }, a[s] = n), n.coins.push(t), n.amount = n.amount.plus(t.balance);
+      }), this.balances = a;
+    }
+  }
+  /**
+   * Gets balance information for a specific coin type
+   *
+   * @param coinType - The coin type to query
+   * @returns UserCoinBalance object with coin type, total amount, and coin objects
+   */
+  getBalance(e) {
+    return e = P(e), this.balances[e] || { coinType: e, amount: x(0), coins: [] };
+  }
+  /**
+   * Gets all coin types in the portfolio
+   *
+   * @returns Array of coin type strings
+   */
+  getCoinTypes() {
+    return Object.values(this.balances).map((e) => e.coinType);
+  }
+  /**
+   * Gets the total balance amount for a specific coin type
+   *
+   * @param coinType - The coin type to query
+   * @returns BigNumber representing the total balance
+   */
+  balanceOf(e) {
+    e = P(e);
+    const a = this.getBalance(e);
+    return (a == null ? void 0 : a.amount) || x(0);
+  }
+  /**
+   * Creates a deep copy of the portfolio
+   *
+   * This method creates a completely independent copy of the portfolio
+   * that can be modified without affecting the original.
+   *
+   * @returns New UserPortfolio instance with copied data
+   */
+  clone() {
+    const e = JSON.parse(JSON.stringify(this.balances)), a = new B();
+    return a.balances = e, a;
+  }
+}
+class ne extends T {
+  constructor() {
+    super(...arguments), this.name = "balance", this.defaultConfig = {
+      coinPollingInterval: 6e3
+    }, this.updatePortfolio = j(async () => {
+      if (!this.walletClient)
+        throw new Error("Wallet client not found");
+      this._coins = await K(this.walletClient.address, {
+        client: this.walletClient.client
+      }), this._portfolio = new B(this._coins), this.emit("balance:portfolio-updated", {});
+    }), this._coins = [], this._portfolio = new B(), this.pollingTimer = null, this._updatePromise = null;
+  }
+  /**
+   * Gets the current coin objects from the wallet
+   *
+   * @returns Array of coin objects owned by the wallet
+   */
+  get coins() {
+    return this._coins;
+  }
+  /**
+   * Gets the current portfolio information
+   *
+   * @returns UserPortfolio instance with current balance information
+   */
+  get portfolio() {
+    return this._portfolio;
+  }
+  /**
+   * Waits for the next portfolio update to complete
+   *
+   * @returns Promise that resolves when the portfolio is updated
+   * @throws Error if no update promise is available
+   */
+  async waitForUpdate() {
+    if (!this._updatePromise)
+      throw new Error("Update promise not found");
+    return await this._updatePromise;
+  }
+  /**
+   * Sends a single coin to a recipient
+   *
+   * @param coinType - Type of coin to send
+   * @param recipient - Recipient address
+   * @param amount - Amount to send
+   * @param options - Optional parameters including dry run mode
+   * @returns Transaction response or dry run response
+   */
+  async sendCoin(e, a, t, s) {
+    return this.sendCoinBatch(e, [a], [t], s);
+  }
+  /**
+   * Sends coins to multiple recipients in a single transaction
+   *
+   * @param coinType - Type of coin to send
+   * @param recipients - Array of recipient addresses
+   * @param amounts - Array of amounts to send (must match recipients length)
+   * @param options - Optional parameters including dry run mode
+   * @returns Transaction response or dry run response
+   */
+  async sendCoinBatch(e, a, t, s) {
+    var h;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    if (a.length !== t.length)
+      throw new Error("Recipients and amounts must have the same length");
+    await this.waitForUpdate();
+    const n = this.portfolio.getBalance(e), r = t.reduce((g, f) => g.plus(f), S(0));
+    if (n.amount.lt(r))
+      throw new Error("Insufficient balance");
+    const l = new d();
+    let i = l.gas;
+    P(e) !== P("0x2::sui::SUI") && (i = w(l, n.coins, {
+      balance: r.toNumber()
+    }));
+    const c = l.splitCoins(i, t);
+    return a.forEach((g, f) => {
+      l.transferObjects([c[f]], g);
+    }), await this.walletClient.signExecuteTransaction({
+      transaction: l,
+      dryRun: (h = s == null ? void 0 : s.dryRun) != null ? h : !1
+    });
+  }
+  /**
+   * Transfers a single object to a recipient
+   *
+   * @param object - Object ID to transfer
+   * @param recipient - Recipient address
+   * @param options - Optional parameters including dry run mode
+   * @returns Transaction response or dry run response
+   */
+  async transferObject(e, a, t) {
+    return this.transferObjectBatch([e], [a], t);
+  }
+  /**
+   * Transfers multiple objects to their respective recipients in a single transaction
+   *
+   * Each object is transferred to its corresponding recipient by index
+   * (first object → first recipient, second object → second recipient, etc.)
+   *
+   * @param objects - Object IDs to transfer
+   * @param recipients - Recipient addresses (must match objects array length)
+   * @param options - Optional parameters including dry run mode
+   * @returns Transaction response or dry run response
+   */
+  async transferObjectBatch(e, a, t) {
+    var r;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    if (e.length !== a.length)
+      throw new Error("Objects and recipients must have the same length");
+    await this.waitForUpdate();
+    const s = new d();
+    return e.forEach((l, i) => {
+      s.transferObjects([s.object(l)], a[i]);
+    }), await this.walletClient.signExecuteTransaction({
+      transaction: s,
+      dryRun: (r = t == null ? void 0 : t.dryRun) != null ? r : !1
+    });
+  }
+  /**
+   * Starts polling for portfolio updates
+   *
+   * This method recursively schedules itself to run at the configured
+   * interval, ensuring regular balance updates.
+   */
+  async startPolling() {
+    try {
+      await this.updatePortfolio();
+    } catch (e) {
+      console.error(e);
+    } finally {
+      this.pollingTimer = setTimeout(this.startPolling, this.config.coinPollingInterval);
+    }
+  }
+  /**
+   * Installs the balance module into a wallet client
+   *
+   * @param walletClient - The wallet client instance to install into
+   */
+  install(e) {
+    super.install(e), this.startPolling = this.startPolling.bind(this), this.startPolling(), this._updatePromise = new Promise((a) => {
+      e.events.on("balance:portfolio-updated", () => {
+        a();
+      });
+    });
+  }
+  /**
+   * Uninstalls the balance module from the wallet client
+   *
+   * This method cleans up timers and stops polling to prevent memory leaks.
+   */
+  uninstall() {
+    super.uninstall(), this.pollingTimer && (clearTimeout(this.pollingTimer), this.pollingTimer = null);
+  }
+}
+class se extends T {
+  constructor() {
+    super(...arguments), this.name = "lending", this.defaultConfig = {
+      env: "prod"
+    };
+  }
+  /**
+   * Gets all available lending pools
+   *
+   * @param options - Optional caching options
+   * @returns Array of pool information
+   */
+  async getPools(e) {
+    return await N({
+      env: this.config.env,
+      ...e
+    });
+  }
+  /**
+   * Gets information for a specific lending pool
+   *
+   * @param identifier - Asset identifier (string, Pool object, or number)
+   * @param options - Optional caching options
+   * @returns Pool information
+   */
+  async getPool(e, a) {
+    return await m(e, {
+      env: this.config.env,
+      ...a
+    });
+  }
+  /**
+   * Deposits coins into a lending pool
+   *
+   * @param identifier - Asset identifier for the pool
+   * @param amount - Amount to deposit
+   * @param options - Optional parameters including dry run mode and account capability
+   * @returns Transaction response or dry run response
+   */
+  async deposit(e, a, t) {
+    var c, u, h;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const s = await m(e, {
+      env: this.config.env
+    });
+    await this.walletClient.module("balance").waitForUpdate();
+    const n = new d(), r = this.walletClient.module("balance").portfolio.getBalance(s.suiCoinType), l = w(n, r.coins, {
+      balance: a,
+      useGasCoin: !0
+    });
+    await q(n, s, l, {
+      env: this.config.env,
+      amount: a,
+      accountCap: t == null ? void 0 : t.accountCap
+    });
+    const i = await this.walletClient.signExecuteTransaction({
+      transaction: n,
+      dryRun: (c = t == null ? void 0 : t.dryRun) != null ? c : !1
+    });
+    return !(t != null && t.dryRun) && ((h = (u = i.effects) == null ? void 0 : u.status) == null ? void 0 : h.status) === "success" && (this.emit("lending:deposit-success", {
+      identifier: e,
+      amount: a
+    }), this.walletClient.module("balance").updatePortfolio()), i;
+  }
+  /**
+   * Withdraws coins from a lending pool
+   *
+   * @param identifier - Asset identifier for the pool
+   * @param amount - Amount to withdraw
+   * @param options - Optional parameters including dry run mode and account capability
+   * @returns Transaction response or dry run response
+   */
+  async withdraw(e, a, t) {
+    var i, c, u;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const s = await m(e, {
+      env: this.config.env
+    }), n = new d();
+    t != null && t.disableUpdateOracle || await this.updateOraclePTB(n, [s]);
+    const r = await L(n, s, a, {
+      env: this.config.env,
+      accountCap: t == null ? void 0 : t.accountCap
+    });
+    n.transferObjects([r], this.walletClient.address);
+    const l = await this.walletClient.signExecuteTransaction({
+      transaction: n,
+      dryRun: (i = t == null ? void 0 : t.dryRun) != null ? i : !1
+    });
+    return !(t != null && t.dryRun) && ((u = (c = l.effects) == null ? void 0 : c.status) == null ? void 0 : u.status) === "success" && (this.emit("lending:withdraw-success", {
+      identifier: e,
+      amount: a
+    }), this.walletClient.module("balance").updatePortfolio()), l;
+  }
+  /**
+   * Borrows coins from a lending pool
+   *
+   * @param identifier - Asset identifier for the pool
+   * @param amount - Amount to borrow
+   * @param options - Optional parameters including dry run mode and account capability
+   * @returns Transaction response or dry run response
+   */
+  async borrow(e, a, t) {
+    var i, c, u;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const s = await m(e, {
+      env: this.config.env
+    }), n = new d();
+    t != null && t.disableUpdateOracle || await this.updateOraclePTB(n, [s]);
+    const r = await M(n, s, a, {
+      env: this.config.env,
+      accountCap: t == null ? void 0 : t.accountCap
+    });
+    n.transferObjects([r], this.walletClient.address);
+    const l = await this.walletClient.signExecuteTransaction({
+      transaction: n,
+      dryRun: (i = t == null ? void 0 : t.dryRun) != null ? i : !1
+    });
+    return !(t != null && t.dryRun) && ((u = (c = l.effects) == null ? void 0 : c.status) == null ? void 0 : u.status) === "success" && (this.emit("lending:borrow-success", {
+      identifier: e,
+      amount: a
+    }), this.walletClient.module("balance").updatePortfolio()), l;
+  }
+  /**
+   * Repays borrowed coins to a lending pool
+   *
+   * @param identifier - Asset identifier for the pool
+   * @param amount - Amount to repay
+   * @param options - Optional parameters including dry run mode and account capability
+   * @returns Transaction response or dry run response
+   */
+  async repay(e, a, t) {
+    var c, u, h;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    await this.walletClient.module("balance").waitForUpdate();
+    const s = await m(e, {
+      env: this.config.env
+    }), n = new d(), r = this.walletClient.module("balance").portfolio.getBalance(s.suiCoinType), l = w(n, r.coins, {
+      balance: a,
+      useGasCoin: !0
+    });
+    await $(n, s, l, {
+      env: this.config.env,
+      amount: a,
+      accountCap: t == null ? void 0 : t.accountCap
+    });
+    const i = await this.walletClient.signExecuteTransaction({
+      transaction: n,
+      dryRun: (c = t == null ? void 0 : t.dryRun) != null ? c : !1
+    });
+    return !(t != null && t.dryRun) && ((h = (u = i.effects) == null ? void 0 : u.status) == null ? void 0 : h.status) === "success" && (this.emit("lending:repay-success", {
+      identifier: e,
+      amount: a
+    }), this.walletClient.module("balance").updatePortfolio()), i;
+  }
+  /**
+   * Gets the current health factor for the user
+   *
+   * @returns Current health factor value
+   */
+  async getHealthFactor() {
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const e = this.walletClient.address;
+    return await G(e, {
+      env: this.config.env,
+      client: this.walletClient.client
+    });
+  }
+  /**
+   * Initiates a liquidation process
+   *
+   * @param payIdentifier - Asset identifier for the debt being paid
+   * @param payAmount - Amount of debt to pay
+   * @param collateralIdentifier - Asset identifier for the collateral being liquidated
+   * @param liquidationAddress - Address of the account being liquidated
+   * @param options - Optional parameters including dry run mode
+   * @returns Transaction response or dry run response
+   */
+  async liquidate(e, a, t, s, n) {
+    var b, y, v;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const r = await m(e, {
+      env: this.config.env
+    }), l = await m(t, {
+      env: this.config.env
+    }), i = new d(), c = this.walletClient.module("balance").portfolio.getBalance(r.suiCoinType), u = w(i, c.coins, {
+      balance: a,
+      useGasCoin: !0
+    }), [h, g] = await H(
+      i,
+      r,
+      u,
+      l,
+      s,
+      {
+        env: this.config.env
+      }
+    ), [f] = i.moveCall({
+      target: "0x2::coin::from_balance",
+      arguments: [h],
+      typeArguments: [l.suiCoinType]
+    }), [E] = i.moveCall({
+      target: "0x2::coin::from_balance",
+      arguments: [g],
+      typeArguments: [r.suiCoinType]
+    });
+    i.transferObjects([f, E], this.walletClient.address);
+    const C = await this.walletClient.signExecuteTransaction({
+      transaction: i,
+      dryRun: (b = n == null ? void 0 : n.dryRun) != null ? b : !1
+    });
+    return !(n != null && n.dryRun) && ((v = (y = C.effects) == null ? void 0 : y.status) == null ? void 0 : v.status) === "success" && (this.emit("lending:liquidate-success", {
+      payIdentifier: e,
+      payAmount: a,
+      collateralIdentifier: t,
+      liquidationAddress: s
+    }), this.walletClient.module("balance").updatePortfolio()), C;
+  }
+  /**
+   * Gets the available lending rewards for the current user.
+   *
+   * @param options - Optional cache options.
+   * @returns The available lending rewards for the user.
+   * @throws If the wallet client is not found.
+   */
+  async getAvailableRewards(e) {
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    return O(this.walletClient.address, {
+      ...e,
+      env: this.config.env
+    });
+  }
+  /**
+   * Gets the claimed reward history for the current user.
+   *
+   * @param options - Optional cache options.
+   * @returns The claimed reward history for the user.
+   * @throws If the wallet client is not found.
+   */
+  async getClaimedRewardHistory(e) {
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    return J(this.walletClient.address, {
+      ...e
+    });
+  }
+  /**
+   * Claims all available lending rewards for the user
+   *
+   * @param options - Optional parameters including dry run mode and account capability
+   * @returns Transaction response or dry run response
+   */
+  async claimAllRewards(e) {
+    var n, r, l;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const a = new d(), t = await O(this.walletClient.address, {
+      env: this.config.env
+    });
+    await z(a, t, {
+      env: this.config.env,
+      accountCap: e == null ? void 0 : e.accountCap
+    });
+    const s = await this.walletClient.signExecuteTransaction({
+      transaction: a,
+      dryRun: (n = e == null ? void 0 : e.dryRun) != null ? n : !1
+    });
+    return !(e != null && e.dryRun) && ((l = (r = s.effects) == null ? void 0 : r.status) == null ? void 0 : l.status) === "success" && (this.emit("lending:claim-rewards-success", {
+      rewards: t
+    }), this.walletClient.module("balance").updatePortfolio()), s;
+  }
+  async updateOraclePTB(e, a) {
+    const t = await D({
+      env: this.config.env
+    }), s = await this.getLendingState({
+      cacheTime: 60 * 1e3
+    }), n = Q(t, {
+      lendingState: s,
+      pools: a
+    });
+    await V(e, n, {
+      env: this.config.env,
+      updatePythPriceFeeds: !0
+    });
+  }
+  /**
+   * Updates the oracle prices for the lending protocol
+   *
+   * @param options - Optional parameters including dry run mode and pools
+   * @param options.dryRun - Whether to perform a dry run
+   * @returns Transaction response or dry run response
+   */
+  async updateOracle(e) {
+    var s;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const a = new d();
+    return await this.updateOraclePTB(a, e == null ? void 0 : e.pools), await this.walletClient.signExecuteTransaction({
+      transaction: a,
+      dryRun: (s = e == null ? void 0 : e.dryRun) != null ? s : !1
+    });
+  }
+  /**
+   * Gets all active lending positions for the user
+   *
+   * @param options - Optional caching options
+   * @returns User's lending state information
+   */
+  async getLendingState(e) {
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    return await X(this.walletClient.address, {
+      env: this.config.env,
+      ...e,
+      client: this.walletClient.client
+    });
+  }
+  /**
+   * Creates an account capability for the lending protocol
+   *
+   * @param options - Optional parameters including dry run mode
+   * @returns Transaction response or dry run response
+   */
+  async createAccountCap(e) {
+    var n;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const a = new d(), t = await Y(a);
+    return a.transferObjects([t], this.walletClient.address), await this.walletClient.signExecuteTransaction({
+      transaction: a,
+      dryRun: (n = e == null ? void 0 : e.dryRun) != null ? n : !1
+    });
+  }
+}
+class le extends T {
+  constructor() {
+    super(...arguments), this.name = "volo", this.defaultConfig = {
+      packageId: "0x68d22cf8bdbcd11ecba1e094922873e4080d4d11133e2443fddda0bfd11dae20",
+      poolId: "0x2d914e23d82fedef1b5f56a32d5c64bdcc3087ccfea2b4d6ea51a71f587840e5",
+      metadataId: "0x680cd26af32b2bde8d3361e804c53ec1d1cfe24c7f039eb7f549e8dfde389a60",
+      coinType: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT"
+    }, this.getStats = k(
+      j(async () => (await fetch("https://open-api.naviprotocol.io/api/volo/stats").then((a) => a.json())).data)
+    );
+  }
+  /**
+   * Adds staking operation to a transaction black
+   *
+   * @param tx - The transaction block to add the staking operation to
+   * @param suiCoin - The SUI coin object to stake
+   * @returns The vSUI coin object received from staking
+   */
+  async stakePTB(e, a) {
+    const [t] = e.moveCall({
+      target: `${this.config.packageId}::stake_pool::stake`,
+      arguments: [
+        e.object(this.config.poolId),
+        e.object(this.config.metadataId),
+        e.object("0x05"),
+        R(a, e.object)
+      ],
+      typeArguments: []
+    });
+    return t;
+  }
+  /**
+   * Adds unstaking operation to a transaction black
+   *
+   * @param tx - The transaction block to add the unstaking operation to
+   * @param vSuiCoin - The vSUI coin object to unstake
+   * @returns The SUI coin object received from unstaking
+   */
+  async unstakePTB(e, a) {
+    const [t] = e.moveCall({
+      target: `${this.config.packageId}::stake_pool::unstake`,
+      arguments: [
+        e.object(this.config.poolId),
+        e.object(this.config.metadataId),
+        e.object("0x05"),
+        R(a, e.object)
+      ],
+      typeArguments: []
+    });
+    return t;
+  }
+  /**
+   * Stake SUI tokens to receive vSUI tokens
+   *
+   * @param suiAmount - Amount of SUI to stake (in MIST units)
+   * @param options - Optional parameters including dryRun flag
+   * @returns Transaction response or dry run response
+   * @throws Error if wallet client not found or stake amount is too low
+   */
+  async stake(e, a) {
+    var i, c, u;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    if (e < 1e9)
+      throw new Error("Stake amount should be greater than 1Sui");
+    const t = new d();
+    await this.walletClient.module("balance").waitForUpdate();
+    const s = this.walletClient.module("balance").portfolio.getBalance("0x2::sui::SUI"), n = w(t, s.coins, {
+      balance: e,
+      useGasCoin: !0
+    }), r = await this.stakePTB(t, n);
+    t.transferObjects([r], this.walletClient.address);
+    const l = await this.walletClient.signExecuteTransaction({
+      transaction: t,
+      dryRun: (i = a == null ? void 0 : a.dryRun) != null ? i : !1
+    });
+    return !(a != null && a.dryRun) && ((u = (c = l.effects) == null ? void 0 : c.status) == null ? void 0 : u.status) === "success" && (this.emit("volo:stake-success", {
+      suiAmount: e
+    }), this.walletClient.module("balance").updatePortfolio()), l;
+  }
+  /**
+   * Unstake vSUI tokens to receive SUI tokens
+   *
+   * @param vSuiAmount - Amount of vSUI to unstake (in MIST units)
+   * @param options - Optional parameters including dryRun flag
+   * @returns Transaction response or dry run response
+   * @throws Error if wallet client not found or unstake amount is too low
+   */
+  async unstake(e, a) {
+    var i, c, u;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    if (e < 1e9)
+      throw new Error("Unstake amount should >= 1vSui");
+    await this.walletClient.module("balance").waitForUpdate();
+    const t = new d(), s = this.walletClient.module("balance").portfolio.getBalance(this.config.coinType), n = w(t, s.coins, {
+      balance: e
+    }), r = await this.unstakePTB(t, n);
+    t.transferObjects([r], this.walletClient.address);
+    const l = await this.walletClient.signExecuteTransaction({
+      transaction: t,
+      dryRun: (i = a == null ? void 0 : a.dryRun) != null ? i : !1
+    });
+    return !(a != null && a.dryRun) && ((u = (c = l.effects) == null ? void 0 : c.status) == null ? void 0 : u.status) === "success" && (this.emit("volo:unstake-success", {
+      vSuiAmount: e
+    }), this.walletClient.module("balance").updatePortfolio()), l;
+  }
+}
+class ie extends T {
+  constructor() {
+    super(...arguments), this.name = "swap", this.defaultConfig = {
+      apiKey: "",
+      baseUrl: "https://open-aggregator-api.naviprotocol.io/find_routes",
+      dexList: [],
+      depth: 3,
+      serviceFee: void 0,
+      env: "prod"
+    };
+  }
+  /**
+   * Gets the referral ID for this swap module
+   *
+   * @returns Referral ID if API key is configured, otherwise 0
+   */
+  get referral() {
+    return this.config.apiKey ? Z(this.config.apiKey) : 0;
+  }
+  /**
+   * Executes a swap between two coin types
+   *
+   * This method performs a complete swap operation including:
+   * - Balance validation
+   * - Quote retrieval from aggregator
+   * - Transaction building with slippage protection
+   * - Transaction execution
+   * - Event emission on success
+   *
+   * @param fromCoinType - Source coin type
+   * @param toCoinType - Target coin type
+   * @param fromAmount - Amount to swap
+   * @param slippage - Slippage tolerance (0-1)
+   * @param options - Optional parameters including dry run mode
+   * @returns Transaction response or dry run response
+   */
+  async swap(e, a, t, s, n) {
+    var E, C, b, y;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    await this.walletClient.module("balance").waitForUpdate();
+    const r = this.walletClient.module("balance").portfolio.getBalance(e), l = new d(), i = w(l, r.coins, {
+      balance: t,
+      useGasCoin: !0
+    }), c = {
+      baseUrl: this.config.baseUrl,
+      dexList: this.config.dexList,
+      depth: this.config.depth,
+      serviceFee: this.config.serviceFee
+    }, u = await ee(
+      e,
+      a,
+      t,
+      this.config.apiKey,
+      c
+    ), h = new S(u.amount_out).multipliedBy(1 - s).toFixed(0), g = await te(
+      this.walletClient.address,
+      l,
+      Number(h),
+      i,
+      u,
+      this.referral,
+      !1,
+      this.config.apiKey,
+      c
+    );
+    l.transferObjects([g], this.walletClient.address);
+    const f = await this.walletClient.signExecuteTransaction({
+      transaction: l,
+      dryRun: (E = n == null ? void 0 : n.dryRun) != null ? E : !1
+    });
+    if (!(n != null && n.dryRun) && ((b = (C = f.effects) == null ? void 0 : C.status) == null ? void 0 : b.status) === "success") {
+      const v = (y = f.events) == null ? void 0 : y.find((I) => I.type.includes("::slippage::SwapEvent"));
+      v && this.emit("swap:swap-success", {
+        fromCoinType: e,
+        toCoinType: a,
+        fromAmount: t,
+        slippage: s,
+        toAmount: Number(v.parsedJson.amount_out)
+      }), this.walletClient.module("balance").updatePortfolio();
+    }
+    return f;
+  }
+}
+class re extends T {
+  constructor() {
+    super(...arguments), this.name = "haedal", this.defaultConfig = {
+      packageId: "0x3f45767c1aa95b25422f675800f02d8a813ec793a00b60667d071a77ba7178a2",
+      configId: "0x47b224762220393057ebf4f70501b6e657c3e56684737568439a04f80849b2ca",
+      coinType: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::hasui::HASUI"
+    }, this.getApy = k(
+      j(async () => (await fetch("https://open-api.naviprotocol.io/api/haedal/stats").then((a) => a.json())).data.apy)
+    );
+  }
+  /**
+   * Builds a transaction block for staking SUI to haSUI
+   *
+   * @param tx - Transaction to add staking operation to
+   * @param suiCoin - Sui coin object to stake
+   * @returns haSUI coin object
+   */
+  async stakePTB(e, a) {
+    const [t] = e.moveCall({
+      target: `${this.config.packageId}::staking::request_stake_coin`,
+      arguments: [
+        e.object("0x05"),
+        e.object(this.config.configId),
+        R(a, e.object),
+        e.pure.address("0x0000000000000000000000000000000000000000000000000000000000000000")
+      ],
+      typeArguments: []
+    });
+    return t;
+  }
+  /**
+   * Builds a transaction block for unstaking haSUI to SUI
+   *
+   * @param tx - Transaction to add unstaking operation to
+   * @param haSUICoin - haSUI coin object to unstake
+   * @returns SUI coin object
+   */
+  async unstakePTB(e, a) {
+    const [t] = e.moveCall({
+      target: `${this.config.packageId}::staking::request_unstake_instant_coin`,
+      arguments: [
+        e.object("0x05"),
+        e.object(this.config.configId),
+        R(a, e.object)
+      ],
+      typeArguments: []
+    });
+    return t;
+  }
+  /**
+   * Stake SUI for haSUI
+   *
+   * @param suiAmount - Amount of SUI to stake
+   * @param options Optional dry run
+   */
+  async stake(e, a) {
+    var i, c, u;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    const t = new d();
+    await this.walletClient.module("balance").waitForUpdate();
+    const s = this.walletClient.module("balance").portfolio.getBalance("0x2::sui::SUI"), n = w(t, s.coins, {
+      balance: e,
+      useGasCoin: !0
+    }), r = await this.stakePTB(t, n);
+    t.transferObjects([r], this.walletClient.address);
+    const l = await this.walletClient.signExecuteTransaction({
+      transaction: t,
+      dryRun: (i = a == null ? void 0 : a.dryRun) != null ? i : !1
+    });
+    return !(a != null && a.dryRun) && ((u = (c = l.effects) == null ? void 0 : c.status) == null ? void 0 : u.status) === "success" && (this.emit("haedal:stake-success", { suiAmount: e }), this.walletClient.module("balance").updatePortfolio()), l;
+  }
+  /**
+   * Unstake haSUI for SUI
+   *
+   * @param haSUIAmount - Amount of haSUI to unstake
+   * @param options Optional dry run
+   */
+  async unstake(e, a) {
+    var i, c, u;
+    if (!this.walletClient)
+      throw new Error("Wallet client not found");
+    await this.walletClient.module("balance").waitForUpdate();
+    const t = new d(), s = this.walletClient.module("balance").portfolio.getBalance(this.config.coinType), n = w(t, s.coins, {
+      balance: e
+    }), r = await this.unstakePTB(t, n);
+    t.transferObjects([r], this.walletClient.address);
+    const l = await this.walletClient.signExecuteTransaction({
+      transaction: t,
+      dryRun: (i = a == null ? void 0 : a.dryRun) != null ? i : !1
+    });
+    return !(a != null && a.dryRun) && ((u = (c = l.effects) == null ? void 0 : c.status) == null ? void 0 : u.status) === "success" && (this.emit("haedal:unstake-success", { haSUIAmount: e }), this.walletClient.module("balance").updatePortfolio()), l;
+  }
+}
+const ce = {
+  /** Balance management module */
+  balance: new ne(),
+  /** Lending protocol module */
+  lending: new se(),
+  /** Volo protocol module */
+  volo: new le(),
+  /** DEX swapping module */
+  swap: new ie(),
+  /** Haedal protocol module */
+  haedal: new re()
+}, ue = {
+  url: F("mainnet")
+};
+class ye {
+  /**
+   * Creates a new wallet client instance
+   * @param options - Configuration options for the wallet client
+   */
+  constructor(e) {
+    this.modules = ce, this.userConfigs = {}, this.events = _();
+    const a = {
+      ...ue,
+      ...e.client
+    };
+    a.transport = a.transport || new ae(a.url), this.client = new W(a), this.signer = e.signer, this.userConfigs = e.configs || {}, Object.entries(this.modules).forEach(([t, s]) => {
+      if (t !== s.name)
+        throw new Error(`Module name ${t} does not match module name ${s.name}`);
+      s.install(this);
+    });
+  }
+  get lending() {
+    return this.modules.lending;
+  }
+  get balance() {
+    return this.modules.balance;
+  }
+  get volo() {
+    return this.modules.volo;
+  }
+  get swap() {
+    return this.modules.swap;
+  }
+  get haedal() {
+    return this.modules.haedal;
+  }
+  /**
+   * Signs and executes a transaction block
+   * @param options - Transaction execution options including dry run support
+   * @returns Promise with transaction execution result
+   */
+  async signExecuteTransaction(e) {
+    const { dryRun: a = !1, ...t } = e;
+    if (a) {
+      let s;
+      return e.transaction instanceof d ? (e.transaction.setSenderIfNotSet(this.address), s = await e.transaction.build({
+        client: this.client
+      })) : s = e.transaction, this.client.dryRunTransactionBlock({
+        transactionBlock: s
+      });
+    }
+    return this.client.signAndExecuteTransaction({
+      ...t,
+      signer: this.signer
+    });
+  }
+  /**
+   * Gets the wallet address from the signer's public key
+   * @returns The wallet address as a string
+   */
+  get address() {
+    return this.signer.getPublicKey().toSuiAddress();
+  }
+  /**
+   * Gets a specific module by name
+   * @param name - The name of the module to retrieve
+   * @returns The requested module instance
+   */
+  module(e) {
+    return this.modules[e];
+  }
+  /**
+   * Gets the configuration for a specific module
+   * @param name - The name of the module
+   * @returns The merged configuration (default + user config)
+   */
+  config(e) {
+    return {
+      ...this.modules[e].defaultConfig,
+      ...this.userConfigs[e]
+    };
+  }
+  /**
+   * Checks if a module is available
+   * @param name - The name of the module to check
+   * @returns True if the module exists, false otherwise
+   */
+  hasModule(e) {
+    return e in this.modules;
+  }
+}
+class ve extends U {
+  /**
+   * Creates a new watch-only signer
+   *
+   * @param address - The wallet address to watch
+   */
+  constructor(e) {
+    super(), this.address = e;
+  }
+  /**
+   * Signs transaction bytes (not implemented for watch-only mode)
+   *
+   * This method is required by the Signer interface but cannot
+   * actually sign transactions in watch-only mode.
+   *
+   * @param bytes - Transaction bytes to sign
+   * @returns Promise<Uint8Array> - Empty signature (not valid)
+   */
+  async sign(e) {
+    return new Uint8Array([]);
+  }
+  /**
+   * Gets the public key information for this signer
+   *
+   * Returns a mock public key object that provides the wallet address
+   * but cannot be used for actual cryptographic operations.
+   *
+   * @returns Mock public key object
+   */
+  getPublicKey() {
+    return {
+      /** Returns the wallet address */
+      toSuiAddress: () => this.address,
+      /** Returns empty bytes (not a real public key) */
+      toBytes: () => new Uint8Array(32),
+      /** Returns empty raw bytes (not a real public key) */
+      toRawBytes: () => new Uint8Array(32),
+      /** Public key flag (0 for mock) */
+      flag: 0,
+      /** Verification always returns false (not a real public key) */
+      verify: async () => !1
+    };
+  }
+  /**
+   * Gets the key scheme for this signer
+   *
+   * @returns Key scheme string (ed25519 for compatibility)
+   */
+  getKeyScheme() {
+    return "ed25519";
+  }
+  /**
+   * Signs and executes a transaction (not implemented for watch-only mode)
+   *
+   * This method is required by the Signer interface but cannot
+   * actually sign and execute transactions in watch-only mode.
+   *
+   * @param options - Sign and execute options
+   * @returns Promise<any> - Empty result (not a real transaction result)
+   */
+  async signAndExecuteTransaction({ transaction: e, client: a }) {
+    return {};
+  }
+}
+class Pe extends U {
+  /**
+   * Creates a new watch-only signer
+   *
+   * @param address - The wallet address to watch
+   */
+  constructor(e) {
+    super(), this.address = e;
+  }
+  /**
+   * Signs transaction bytes (not implemented for watch-only mode)
+   *
+   * This method is required by the Signer interface but cannot
+   * actually sign transactions in watch-only mode.
+   *
+   * @param bytes - Transaction bytes to sign
+   * @returns Promise<Uint8Array> - Empty signature (not valid)
+   */
+  async sign(e) {
+    return new Uint8Array([]);
+  }
+  /**
+   * Gets the public key information for this signer
+   *
+   * Returns a mock public key object that provides the wallet address
+   * but cannot be used for actual cryptographic operations.
+   *
+   * @returns Mock public key object
+   */
+  getPublicKey() {
+    return {
+      /** Returns the wallet address */
+      toSuiAddress: () => this.address,
+      /** Returns empty bytes (not a real public key) */
+      toBytes: () => new Uint8Array(32),
+      /** Returns empty raw bytes (not a real public key) */
+      toRawBytes: () => new Uint8Array(32),
+      /** Public key flag (0 for mock) */
+      flag: 0,
+      /** Verification always returns false (not a real public key) */
+      verify: async () => !1
+    };
+  }
+  /**
+   * Gets the key scheme for this signer
+   *
+   * @returns Key scheme string (ed25519 for compatibility)
+   */
+  getKeyScheme() {
+    return "ed25519";
+  }
+}
+export {
+  ye as WalletClient,
+  ve as WatchSigner,
+  Pe as WebSigner
+};
+//# sourceMappingURL=index.esm.js.map