@lombard.finance/sdk 4.6.0 → 4.7.0

package/dist/chunks/events-DAiXVdGv.js

@@ -0,0 +1,1274 @@
+var $ = Object.defineProperty;
+var q = (s, t, e) => t in s ? $(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var a = (s, t, e) => q(s, typeof t != "symbol" ? t + "" : t, e);
+import "axios";
+import { SDK_RUNTIME as z, SDK_VERSION as W, LombardError as d, bitcoinAddressSchema as I, Chain as h, BaseAction as C, NonEvmOperationStatus as i, validatePrepareParams as f, StepStatus as o, objectType as E, amountSchema as A, solanaAddressSchema as w, CapabilityRegistry as S, PartnerConfiguration as _, getProviderGetter as D, ASSET_CATALOG as b, getAssetAddress as X, getAssetDecimals as Z, getAssetMetadata as J, usesAssetRouter as Q, getAssetRouter as tt, getBridgeAdapter as et, getPublicMarketMaker as st, getAssetByAddress as nt, isAssetDeployed as rt, getAssetChains as it, getAssetEnvironments as at, getSupportedAssets as ot, ProviderErrorCode as ct } from "./statusConstants-D9eSk91U.js";
+import { generateDepositBtcAddress as ut } from "./getUserStakeAndBakeSignature-CqlrwA0t.js";
+import { getDepositsByAddress as y, getUnstakesByAddress as ht, getPointsByAddress as dt, getDepositBtcAddress as O, storeStakeAndBakeSignature as gt, ReferralsClient as lt } from "./ReferralsClient-W-0-383w.js";
+import { storeNetworkFeeSignature as pt, getNetworkFeeSignature as mt } from "./storeNetworkFeeSignature-tprCigR1.js";
+import { btcModule as vt, BtcActions as Ct } from "./BtcActions-jvzGFmpz.js";
+import { evmModule as ft, EvmActions as Et } from "./EvmActions-hb-FhsLJ.js";
+import { SOLANA_DEVNET_CHAIN as At, SOLANA_MAINNET_CHAIN as It, getSolanaTokenAddress as L, Token as k } from "./token-addresses-Ddar0FyS.js";
+import { toSatoshi as T } from "./satoshi-CSoJBXc6.js";
+import { p as B, r as c } from "./index-CfcQ_g3t.js";
+import { AssetId as g } from "./defi-registry-CD8EUcNu.js";
+import { getExchangeRatio as St } from "./get-exchange-ratio-Bl6pt546.js";
+import { Vault as _t } from "./config-C8BfN_9P.js";
+import { getVaultWithdrawals as Dt, getVaultWithdrawalsAllChains as Nt } from "./get-vault-withdrawals-QJOdxB5Z.js";
+const P = ["debug", "info", "warn", "error", "none"];
+function Tt(s = {}) {
+  const { level: t = "debug", prefix: e = "[Lombard SDK]", timestamp: n = !1 } = s, r = P.indexOf(t), u = (p) => P.indexOf(p) >= r && t !== "none", l = (p) => {
+    if (n) {
+      const v = (/* @__PURE__ */ new Date()).toISOString();
+      return `${e} ${v} ${p}`;
+    }
+    return `${e} ${p}`;
+  }, m = (p) => !p || Object.keys(p).length === 0 ? [] : [p];
+  return {
+    debug(p, v) {
+      u("debug") && console.debug(l(p), ...m(v));
+    },
+    info(p, v) {
+      u("info") && console.info(l(p), ...m(v));
+    },
+    warn(p, v) {
+      u("warn") && console.warn(l(p), ...m(v));
+    },
+    error(p, v) {
+      u("error") && console.error(l(p), ...m(v));
+    }
+  };
+}
+function me() {
+  return {
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    }
+  };
+}
+function ve() {
+  return {
+    "X-SDK-Version": W,
+    "X-SDK-Runtime": z
+  };
+}
+class xt {
+  constructor(t = B) {
+    /**
+     * Internal API version flag for future v2 migration.
+     * When v2 is ready, we can switch implementations transparently.
+     */
+    a(this, "apiVersion", "v1");
+    this.env = t;
+  }
+  /* -------------------------------------------------------------------------- */
+  /*                               Deposits                                     */
+  /* -------------------------------------------------------------------------- */
+  /**
+   * Fetch all deposits for an address.
+   *
+   * Returns deposits from both Direct BTC Deposits and Native Deposits APIs,
+   * unified into a single list sorted by block time (newest first).
+   *
+   * @param address - The EVM/BTC address to fetch deposits for
+   * @returns Promise resolving to array of Deposit objects
+   *
+   * @example
+   * ```ts
+   * const deposits = await sdk.api.deposits('0x1234...');
+   * deposits.forEach(d => {
+   *   console.log(`${d.amount} BTC deposited at block ${d.blockHeight}`);
+   * });
+   * ```
+   */
+  async deposits(t) {
+    return y({ address: t, env: this.env });
+  }
+  /* -------------------------------------------------------------------------- */
+  /*                               Unstakes                                     */
+  /* -------------------------------------------------------------------------- */
+  /**
+   * Fetch all unstakes/redemptions for an address.
+   *
+   * Returns unstake records for both direct BTC unstakes and
+   * native blockchain redemptions.
+   *
+   * @param address - The address that initiated the unstakes
+   * @param options - Optional filters (show_redeems, show_unstakes, to_native)
+   * @returns Promise resolving to array of Unstake objects
+   *
+   * @example
+   * ```ts
+   * // Get all unstakes
+   * const unstakes = await sdk.api.unstakes('0x1234...');
+   *
+   * // Get only native chain redemptions
+   * const redeems = await sdk.api.unstakes('0x1234...', { to_native: true });
+   * ```
+   */
+  async unstakes(t, e) {
+    return ht({ address: t, env: this.env, options: e });
+  }
+  async points(t, e) {
+    return dt({ address: t, env: this.env, season: e });
+  }
+  /* -------------------------------------------------------------------------- */
+  /*                          Token Exchange Ratios                             */
+  /* -------------------------------------------------------------------------- */
+  /**
+   * Fetch the current exchange ratios for all supported tokens.
+   *
+   * Returns Token:BTC and BTC:Token ratios for LBTC and other supported tokens.
+   * This is the recommended method for getting exchange rate information.
+   *
+   * @returns Promise resolving to exchange ratio info for each token
+   *
+   * @example
+   * ```ts
+   * const ratios = await sdk.api.exchangeRatio();
+   *
+   * // Access LBTC ratios
+   * const lbtcRatio = ratios.LBTC;
+   * console.log(`LBTC:BTC = ${lbtcRatio.tokenBTCRatio}`);  // How many LBTC per 1 BTC
+   * console.log(`BTC:LBTC = ${lbtcRatio.BTCTokenRatio}`);  // How many BTC per 1 LBTC
+   * ```
+   */
+  async exchangeRatio() {
+    return St({ env: this.env });
+  }
+  /* -------------------------------------------------------------------------- */
+  /*                           Deposit Address                                  */
+  /* -------------------------------------------------------------------------- */
+  /**
+   * Get an existing BTC deposit address for a recipient.
+   *
+   * Returns the most recent non-deprecated deposit address for the
+   * given recipient address and destination chain.
+   *
+   * @param address - The destination address where LBTC will be claimed
+   * @param chainId - The destination chain
+   * @param options - Optional partner ID and token type
+   * @returns Promise resolving to the BTC deposit address
+   * @throws Error if no deposit address found
+   *
+   * @example
+   * ```ts
+   * try {
+   *   const btcAddr = await sdk.api.depositAddress('0x1234...', ChainId.ethereum);
+   *   console.log(`Send BTC to: ${btcAddr}`);
+   * } catch (e) {
+   *   console.log('No deposit address found - need to generate one');
+   * }
+   * ```
+   */
+  async depositAddress(t, e, n) {
+    return O({
+      address: t,
+      chainId: e,
+      env: this.env,
+      partnerId: n == null ? void 0 : n.partnerId,
+      token: n == null ? void 0 : n.token
+    });
+  }
+  /* -------------------------------------------------------------------------- */
+  /*                          Vault Withdrawals                                 */
+  /* -------------------------------------------------------------------------- */
+  /**
+   * Fetch all vault withdrawals for an address.
+   *
+   * Returns withdrawal objects categorized by status (cancelled, expired,
+   * fulfilled, open). If chainId is not provided, fetches from all supported chains.
+   *
+   * @param address - The address to fetch withdrawals for
+   * @param options - Optional filters (chainId, vault, rpcUrl)
+   * @returns Promise resolving to categorized vault withdrawals
+   *
+   * @example
+   * ```ts
+   * // Get all withdrawals from all chains
+   * const result = await sdk.api.vaultWithdrawals('0x1234...');
+   * console.log(`Open: ${result.open.length}, Fulfilled: ${result.fulfilled.length}`);
+   *
+   * // Filter by specific chain
+   * const ethereumOnly = await sdk.api.vaultWithdrawals('0x1234...', {
+   *   chainId: ChainId.ethereum,
+   * });
+   *
+   * // Display withdrawal info
+   * result.open.forEach(w => {
+   *   console.log(`Amount: ${w.shareAmount.toFixed()}, Deadline: ${new Date(w.deadline * 1000)}`);
+   * });
+   * ```
+   */
+  async vaultWithdrawals(t, e) {
+    const n = t, r = (e == null ? void 0 : e.vault) ?? _t.Veda;
+    return e != null && e.chainId ? Dt({
+      account: n,
+      chainId: e.chainId,
+      vaultKey: r,
+      rpcUrl: e.rpcUrl,
+      env: this.env
+    }) : Nt({
+      account: n,
+      vaultKey: r,
+      rpcUrl: e == null ? void 0 : e.rpcUrl
+    });
+  }
+  /* -------------------------------------------------------------------------- */
+  /*                            Utility Methods                                 */
+  /* -------------------------------------------------------------------------- */
+  /**
+   * Get the current API version being used.
+   *
+   * @returns The API version string ('v1' or 'v2')
+   */
+  getApiVersion() {
+    return this.apiVersion;
+  }
+}
+function Pt(s) {
+  if (!s.env)
+    throw d.missingParameter("env");
+  const t = {
+    env: s.env,
+    providers: s.providers || {}
+  };
+  return s.partner && (wt(s.partner), t.partner = s.partner), t;
+}
+function wt(s) {
+  if (typeof s != "object" || s === null)
+    throw d.invalidConfiguration(
+      "Partner configuration must be an object"
+    );
+  const t = s;
+  if (!t.partnerId || typeof t.partnerId != "string")
+    throw d.missingParameter("partner.partnerId");
+  if (t.partnerId.trim().length === 0)
+    throw d.invalidConfiguration("Partner ID cannot be empty");
+}
+class bt {
+  constructor(t) {
+    this.env = t;
+  }
+  /**
+   * Generate a new BTC deposit address
+   */
+  async generateDepositAddress(t) {
+    return ut({
+      address: t.address,
+      chainId: t.chainId,
+      signature: t.signature,
+      token: t.token,
+      eip712Data: t.eip712Data,
+      signatureData: t.signatureData,
+      pubKey: t.pubKey,
+      env: this.env,
+      partnerId: t.partnerId,
+      referrerCode: t.referrerCode,
+      captchaToken: t.captchaToken
+    });
+  }
+  /**
+   * Get existing deposit address for a recipient
+   */
+  async getDepositAddress(t) {
+    try {
+      return await O({
+        address: t.address,
+        chainId: t.chainId,
+        token: t.token,
+        env: this.env,
+        partnerId: t.partnerId
+      }) || void 0;
+    } catch {
+      return;
+    }
+  }
+  /**
+   * Get deposits for an address
+   */
+  async getDeposits(t) {
+    return (await y({
+      address: t,
+      env: this.env
+    })).map((n) => {
+      var r;
+      return {
+        depositAddress: n.depositAddress ?? "",
+        blockHeight: n.blockHeight,
+        isClaimed: n.isClaimed,
+        txid: n.txHash,
+        amount: (r = n.amount) == null ? void 0 : r.toString()
+      };
+    });
+  }
+  /**
+   * Store network fee signature
+   */
+  async storeFeeSignature(t) {
+    await pt({
+      address: t.address,
+      signature: t.signature,
+      typedData: t.typedData,
+      env: this.env,
+      tokenAddress: t.tokenAddress
+    });
+  }
+  /**
+   * Get stored network fee signature
+   */
+  async getFeeSignature(t) {
+    return mt({
+      address: t.address,
+      chainId: t.chainId,
+      env: this.env,
+      tokenAddress: t.tokenAddress
+    });
+  }
+  /**
+   * Store stake and bake signature
+   */
+  async storeStakeAndBakeSignature(t) {
+    await gt({
+      signature: t.signature,
+      typedData: t.typedData,
+      env: this.env
+    });
+  }
+}
+function yt() {
+  return {
+    id: "api",
+    register(s) {
+      return new bt(s.env);
+    }
+  };
+}
+function Ot(s) {
+  const t = /* @__PURE__ */ new Map(), e = [vt(), ft(), yt()];
+  for (const n of e)
+    t.set(n.id, n);
+  if (s)
+    for (const n of s)
+      t.set(n.id, n);
+  return Array.from(t.values());
+}
+function Lt(s, t) {
+  for (const e of s)
+    for (const n of e.requiresProviders ?? [])
+      if (!kt(t, n))
+        throw d.providerMissing(n, n);
+}
+function kt(s, t) {
+  var e;
+  return !!((e = s.providers) != null && e[t]);
+}
+function Bt(s) {
+  const t = Pt(s), e = Ot(
+    s.modules
+  );
+  Lt(e, t);
+  let n = s.logger;
+  return !n && s.debug && (n = Tt({ level: "debug" })), {
+    ...t,
+    modules: e,
+    logger: n
+  };
+}
+function x(s) {
+  switch (s) {
+    case "prod":
+      return "mainnet-beta";
+    case "testnet":
+    case "stage":
+    case "dev":
+    case "ibc":
+    default:
+      return "devnet";
+  }
+}
+function M(s) {
+  switch (s) {
+    case "prod":
+      return It;
+    case "testnet":
+    case "stage":
+    case "dev":
+    case "ibc":
+    default:
+      return At;
+  }
+}
+const R = {
+  routes: [
+    {
+      sourceChains: [h.SOLANA_MAINNET],
+      destChain: h.BITCOIN_MAINNET,
+      assetIn: g.BTCb,
+      assetOut: g.BTC,
+      envs: [c.prod]
+    },
+    {
+      sourceChains: [h.SOLANA_DEVNET],
+      destChain: h.BITCOIN_SIGNET,
+      assetIn: g.BTCb,
+      assetOut: g.BTC,
+      envs: [c.testnet, c.stage, c.dev]
+    }
+  ],
+  recipientSchema: I
+};
+function Mt(s, t, e, n, r) {
+  return R.routes.some(
+    (u) => u.sourceChains.includes(s) && u.destChain === t && u.assetIn === e && u.assetOut === n && u.envs.includes(r)
+  );
+}
+class Rt extends C {
+  constructor(e, n) {
+    super(i.IDLE);
+    a(this, "_amount");
+    a(this, "_recipient");
+    a(this, "_txHash");
+    if (this.ctx = e, this.params = n, !Mt(
+      n.sourceChain,
+      n.destChain,
+      n.assetIn,
+      n.assetOut,
+      e.env
+    ))
+      throw d.routeNotFound({
+        assetOut: n.assetOut,
+        sourceChain: n.sourceChain,
+        destChain: n.destChain,
+        env: e.env
+      });
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare(e) {
+    return this.assertStatus(i.IDLE, "prepare"), this.act(async () => {
+      const n = f(this.prepareSchema, e, {
+        destChain: this.params.destChain
+      });
+      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.IDLE, releasing: o.IDLE }
+      });
+    }, i.READY);
+  }
+  async execute() {
+    return this.assertStatus(i.READY, "execute"), this.act(async () => {
+      const e = this._amount, n = this._recipient;
+      if (!e || !n)
+        throw d.missingParameter("amount or recipient");
+      this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.PENDING, releasing: o.IDLE }
+      });
+      const r = T(e).toString(), u = x(this.ctx.env), l = L(
+        M(this.ctx.env),
+        this.ctx.env,
+        k.BTCb
+      );
+      if (!l)
+        throw d.missingParameter("Solana BTC.b mint for this environment");
+      const { signature: m } = await this.ctx.solana.redeemForBtc({
+        amount: r,
+        btcAddress: n,
+        network: u,
+        env: this.ctx.env,
+        tokenMint: l
+      });
+      return this._txHash = m, this.emitProgress({
+        status: i.COMPLETED,
+        steps: { burning: o.COMPLETE, releasing: o.COMPLETE }
+      }), this.emitCompleted(), { txHash: m };
+    }, i.COMPLETED);
+  }
+  get prepareSchema() {
+    return E({
+      amount: A,
+      recipient: R.recipientSchema
+    });
+  }
+}
+const H = {
+  routes: [
+    {
+      chain: h.SOLANA_MAINNET,
+      assetIn: g.BTCb,
+      assetOut: g.LBTC,
+      envs: [c.prod]
+    },
+    {
+      chain: h.SOLANA_DEVNET,
+      assetIn: g.BTCb,
+      assetOut: g.LBTC,
+      envs: [c.stage, c.dev, c.testnet]
+    }
+  ],
+  recipientSchema: w
+};
+function Ht(s, t, e, n) {
+  return H.routes.some(
+    (r) => r.chain === s && r.assetIn === t && r.assetOut === e && r.envs.includes(n)
+  );
+}
+class Ft extends C {
+  constructor(e, n) {
+    super(i.IDLE);
+    a(this, "_amount");
+    a(this, "_recipient");
+    a(this, "_txHash");
+    a(this, "env");
+    if (this.ctx = e, this.params = n, this.env = e.env, !Ht(
+      n.chain,
+      n.assetIn,
+      n.assetOut,
+      this.env
+    ))
+      throw d.routeNotFound({
+        assetOut: n.assetOut,
+        chain: n.chain,
+        env: this.env
+      });
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare(e) {
+    return this.assertStatus(i.IDLE, "prepare"), this.act(async () => {
+      const n = f(this.prepareSchema, e, {
+        destChain: this.params.chain
+      });
+      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.IDLE, minting: o.IDLE }
+      });
+    }, i.READY);
+  }
+  async execute() {
+    return this.assertStatus(i.READY, "execute"), this.act(async () => {
+      const e = this._amount, n = this._recipient;
+      if (!e || !n)
+        throw d.missingParameter("amount or recipient");
+      this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.PENDING, minting: o.IDLE }
+      });
+      const r = T(e).toString(), u = x(this.env), { signature: l } = await this.ctx.solana.deposit({
+        amount: r,
+        recipient: n,
+        network: u,
+        env: this.env
+      });
+      return this._txHash = l, this.emitProgress({
+        status: i.CONFIRMING,
+        steps: { burning: o.COMPLETE, minting: o.PENDING },
+        txHash: l
+      }), this.emitCompleted(), { txHash: l };
+    }, i.CONFIRMING);
+  }
+  get prepareSchema() {
+    return E({
+      amount: A,
+      recipient: H.recipientSchema
+    });
+  }
+}
+const F = {
+  routes: [
+    {
+      sourceChains: [h.SOLANA_MAINNET],
+      destChain: h.BITCOIN_MAINNET,
+      assetIn: g.LBTC,
+      assetOut: g.BTC,
+      envs: [c.prod]
+    },
+    {
+      sourceChains: [h.SOLANA_DEVNET],
+      destChain: h.BITCOIN_SIGNET,
+      assetIn: g.LBTC,
+      assetOut: g.BTC,
+      envs: [c.testnet, c.stage, c.dev, c.ibc]
+    }
+  ],
+  recipientSchema: I
+}, Y = {
+  routes: [
+    {
+      sourceChains: [h.SOLANA_MAINNET],
+      destChain: h.SOLANA_MAINNET,
+      assetIn: g.LBTC,
+      assetOut: g.BTCb,
+      envs: [c.prod]
+    },
+    {
+      sourceChains: [h.SOLANA_DEVNET],
+      destChain: h.SOLANA_DEVNET,
+      assetIn: g.LBTC,
+      assetOut: g.BTCb,
+      envs: [c.stage, c.dev, c.testnet]
+    }
+  ],
+  recipientSchema: w
+}, Yt = [...F.routes, ...Y.routes];
+function Gt(s, t, e, n, r) {
+  return Yt.some(
+    (u) => u.sourceChains.includes(s) && u.destChain === t && u.assetIn === e && u.assetOut === n && u.envs.includes(r)
+  );
+}
+class Ut extends C {
+  constructor(e, n) {
+    super(i.IDLE);
+    a(this, "_amount");
+    a(this, "_recipient");
+    a(this, "_txHash");
+    a(this, "isBtcbOutput");
+    if (this.ctx = e, this.params = n, this.isBtcbOutput = n.assetOut === g.BTCb, !Gt(
+      n.sourceChain,
+      n.destChain,
+      n.assetIn,
+      n.assetOut,
+      e.env
+    ))
+      throw d.routeNotFound({
+        assetOut: n.assetOut,
+        sourceChain: n.sourceChain,
+        destChain: n.destChain,
+        env: e.env
+      });
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare(e) {
+    return this.assertStatus(i.IDLE, "prepare"), this.act(async () => {
+      const n = f(this.prepareSchema, e, {
+        destChain: this.params.destChain
+      });
+      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.IDLE, releasing: o.IDLE }
+      });
+    }, i.READY);
+  }
+  async execute() {
+    return this.assertStatus(i.READY, "execute"), this.act(async () => {
+      const e = this._amount, n = this._recipient;
+      if (!e || !n)
+        throw d.missingParameter("amount or recipient");
+      this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.PENDING, releasing: o.IDLE }
+      });
+      const r = T(e).toString(), u = x(this.ctx.env);
+      let l;
+      if (this.isBtcbOutput)
+        ({ signature: l } = await this.ctx.solana.redeem({
+          amount: r,
+          recipient: n,
+          network: u,
+          env: this.ctx.env
+        }));
+      else {
+        const m = L(
+          M(this.ctx.env),
+          this.ctx.env,
+          k.LBTC
+        );
+        if (!m)
+          throw d.missingParameter(
+            "Solana LBTC mint for this environment"
+          );
+        ({ signature: l } = await this.ctx.solana.redeemForBtc({
+          amount: r,
+          btcAddress: n,
+          network: u,
+          env: this.ctx.env,
+          tokenMint: m
+        }));
+      }
+      return this._txHash = l, this.emitProgress({
+        status: i.COMPLETED,
+        steps: { burning: o.COMPLETE, releasing: o.COMPLETE }
+      }), this.emitCompleted(), { txHash: l };
+    }, i.COMPLETED);
+  }
+  get prepareSchema() {
+    const e = this.isBtcbOutput ? Y : F;
+    return E({
+      amount: A,
+      recipient: e.recipientSchema
+    });
+  }
+}
+function Vt(s) {
+  const e = new S(s.modules, s).require("solana");
+  return {
+    env: s.env,
+    partner: new _(s.partner),
+    getProvider: async (n) => {
+      const r = D(s.providers, n);
+      if (r)
+        return r();
+    },
+    solana: e
+  };
+}
+class G {
+  constructor(t) {
+    a(this, "_ctx", null);
+    this.config = t;
+  }
+  get ctx() {
+    return this._ctx || (this._ctx = Vt(this.config)), this._ctx;
+  }
+  /**
+   * Stake BTC.b → LBTC
+   *
+   * Burns BTC.b on Solana and mints LBTC to the recipient via Asset Router.
+   *
+   * @throws LombardError if solana module is not registered
+   * @throws LombardError if route is not supported
+   */
+  stake(t) {
+    return new Ft(this.ctx, t);
+  }
+  /**
+   * Unstake LBTC → BTC (cross-chain) or LBTC → BTC.b (same-chain)
+   *
+   * Burns LBTC on Solana and outputs BTC or BTC.b depending on `assetOut`:
+   * - BTC: via LBTC program directly (cross-chain to Bitcoin)
+   * - BTC.b: via Asset Router redeem (same-chain on Solana)
+   *
+   * @throws LombardError if solana module is not registered
+   * @throws LombardError if route is not supported
+   */
+  unstake(t) {
+    return new Ut(this.ctx, t);
+  }
+  /**
+   * Redeem BTC.b → BTC (cross-chain)
+   *
+   * Burns BTC.b on Solana and releases BTC to a Bitcoin address via Asset Router.
+   *
+   * @throws LombardError if solana module is not registered
+   * @throws LombardError if route is not supported
+   */
+  redeem(t) {
+    return new Rt(this.ctx, t);
+  }
+}
+function Ce(s) {
+  return new G(s);
+}
+const U = {
+  routes: [
+    {
+      sourceChains: [h.STARKNET_MAINNET],
+      destChain: h.BITCOIN_MAINNET,
+      envs: [c.prod]
+    },
+    {
+      sourceChains: [h.STARKNET_SEPOLIA],
+      destChain: h.BITCOIN_SIGNET,
+      envs: [c.testnet, c.stage, c.dev, c.ibc]
+    }
+  ],
+  recipientSchema: I
+};
+function Kt(s, t) {
+  return U.routes.some(
+    (e) => e.sourceChains.includes(s) && e.envs.includes(t)
+  );
+}
+class jt extends C {
+  constructor(e, n) {
+    super(i.IDLE);
+    a(this, "_amount");
+    a(this, "_recipient");
+    a(this, "_txHash");
+    a(this, "env");
+    if (this.ctx = e, this.params = n, this.env = e.env, !Kt(n.sourceChain, this.env))
+      throw d.routeNotFound({
+        assetOut: n.assetOut,
+        sourceChain: n.sourceChain,
+        destChain: n.destChain,
+        env: this.env
+      });
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare(e) {
+    return this.assertStatus(i.IDLE, "prepare"), this.act(async () => {
+      const n = f(this.prepareSchema, e, {
+        destChain: this.params.destChain
+      });
+      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.IDLE, releasing: o.IDLE }
+      });
+    }, i.READY);
+  }
+  async execute() {
+    return this.assertStatus(i.READY, "execute"), this.act(async () => {
+      const e = this._amount, n = this._recipient;
+      if (!e || !n)
+        throw d.missingParameter("amount or recipient");
+      this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.PENDING, releasing: o.IDLE }
+      });
+      const { txHash: r } = await this.ctx.starknet.unstake({
+        amount: e,
+        btcAddress: n,
+        env: this.env
+      });
+      return this._txHash = r, this.emitProgress({
+        status: i.COMPLETED,
+        steps: { burning: o.COMPLETE, releasing: o.PENDING }
+      }), this.emitCompleted(), { txHash: r };
+    }, i.COMPLETED);
+  }
+  get prepareSchema() {
+    return E({
+      amount: A,
+      recipient: U.recipientSchema
+    });
+  }
+}
+function $t(s) {
+  const e = new S(s.modules, s).require("starknet");
+  return {
+    env: s.env,
+    partner: new _(s.partner),
+    getProvider: async (n) => {
+      const r = D(s.providers, n);
+      if (r)
+        return r();
+    },
+    starknet: e
+  };
+}
+class V {
+  constructor(t) {
+    a(this, "_ctx", null);
+    this.config = t;
+  }
+  get ctx() {
+    return this._ctx || (this._ctx = $t(this.config)), this._ctx;
+  }
+  /**
+   * Unstake LBTC → BTC
+   *
+   * Burns LBTC on Starknet and releases BTC on Bitcoin.
+   *
+   * @throws LombardError if starknet module is not registered
+   */
+  unstake(t) {
+    return new jt(this.ctx, t);
+  }
+}
+function fe(s) {
+  return new V(s);
+}
+const K = {
+  routes: [
+    {
+      sourceChains: [h.SUI_MAINNET],
+      destChain: h.BITCOIN_MAINNET,
+      envs: [c.prod]
+    },
+    {
+      sourceChains: [h.SUI_TESTNET],
+      destChain: h.BITCOIN_SIGNET,
+      envs: [c.testnet, c.stage, c.dev, c.ibc]
+    }
+  ],
+  recipientSchema: I
+};
+function qt(s, t) {
+  return K.routes.some(
+    (e) => e.sourceChains.includes(s) && e.envs.includes(t)
+  );
+}
+function zt(s) {
+  switch (s) {
+    case h.SUI_MAINNET:
+      return "sui:mainnet";
+    case h.SUI_TESTNET:
+      return "sui:testnet";
+    default:
+      return "sui:testnet";
+  }
+}
+class Wt extends C {
+  constructor(e, n) {
+    super(i.IDLE);
+    a(this, "_amount");
+    a(this, "_recipient");
+    a(this, "_txHash");
+    a(this, "env");
+    if (this.ctx = e, this.params = n, this.env = e.env, !qt(n.sourceChain, this.env))
+      throw d.routeNotFound({
+        assetOut: n.assetOut,
+        sourceChain: n.sourceChain,
+        destChain: n.destChain,
+        env: this.env
+      });
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare(e) {
+    return this.assertStatus(i.IDLE, "prepare"), this.act(async () => {
+      const n = f(this.prepareSchema, e, {
+        destChain: this.params.destChain
+      });
+      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.IDLE, releasing: o.IDLE }
+      });
+    }, i.READY);
+  }
+  async execute() {
+    return this.assertStatus(i.READY, "execute"), this.act(async () => {
+      const e = this._amount, n = this._recipient;
+      if (!e || !n)
+        throw d.missingParameter("amount or recipient");
+      this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.PENDING, releasing: o.IDLE }
+      });
+      const r = zt(this.params.sourceChain), { txHash: u } = await this.ctx.sui.unstake({
+        amount: e,
+        btcAddress: n,
+        chainId: r,
+        env: this.env
+      });
+      return this._txHash = u, this.emitProgress({
+        status: i.COMPLETED,
+        steps: { burning: o.COMPLETE, releasing: o.PENDING }
+      }), this.emitCompleted(), { txHash: u };
+    }, i.COMPLETED);
+  }
+  get prepareSchema() {
+    return E({
+      amount: A,
+      recipient: K.recipientSchema
+    });
+  }
+}
+function Xt(s) {
+  const e = new S(s.modules, s).require("sui");
+  return {
+    env: s.env,
+    partner: new _(s.partner),
+    getProvider: async (n) => {
+      const r = D(s.providers, n);
+      if (r)
+        return r();
+    },
+    sui: e
+  };
+}
+class j {
+  constructor(t) {
+    a(this, "_ctx", null);
+    this.config = t;
+  }
+  get ctx() {
+    return this._ctx || (this._ctx = Xt(this.config)), this._ctx;
+  }
+  /**
+   * Unstake LBTC → BTC
+   *
+   * Burns LBTC on Sui and releases BTC on Bitcoin.
+   *
+   * @throws LombardError if sui module is not registered
+   */
+  unstake(t) {
+    return new Wt(this.ctx, t);
+  }
+}
+function Ee(s) {
+  return new j(s);
+}
+class Zt {
+  constructor(t = B, e) {
+    a(this, "catalog");
+    this.env = t, this.catalog = e ?? b;
+  }
+  /** Get token contract address */
+  getAddress(t, e) {
+    return X(t, this.env, e, this.catalog);
+  }
+  /** Get token decimals */
+  getDecimals(t) {
+    return Z(t, this.catalog);
+  }
+  /** Get asset metadata (decimals, symbol, name) */
+  getMetadata(t) {
+    return J(t, this.catalog);
+  }
+  /** Check if asset uses an asset router contract */
+  usesAssetRouter(t, e) {
+    return Q(t, this.env, e, this.catalog);
+  }
+  /** Get asset router contract address */
+  getAssetRouter(t, e) {
+    return tt(t, this.env, e, this.catalog);
+  }
+  /** Get bridge adapter address */
+  getBridgeAdapter(t, e) {
+    return et(t, this.env, e, this.catalog);
+  }
+  /** Get public market maker address */
+  getPublicMarketMaker(t, e) {
+    return st(t, this.env, e, this.catalog);
+  }
+  /** Find asset by contract address (reverse lookup) */
+  getByAddress(t, e) {
+    return nt(t, this.env, e, this.catalog);
+  }
+  /** Check if asset is deployed on a chain */
+  isDeployed(t, e) {
+    return rt(t, this.env, e, this.catalog);
+  }
+  /** Get all chains where asset is deployed */
+  getChains(t) {
+    return it(t, this.env, this.catalog);
+  }
+  /** Get all environments where asset is deployed on a chain */
+  getEnvironments(t, e) {
+    return at(t, e, this.catalog);
+  }
+  /** Get all supported assets */
+  getSupportedAssets() {
+    return ot(this.catalog);
+  }
+  /** Direct access to the asset catalog */
+  getCatalog() {
+    return this.catalog;
+  }
+}
+class Jt {
+  constructor(t) {
+    a(this, "config");
+    a(this, "env");
+    /** Partner configuration manager */
+    a(this, "partnerConfig");
+    /** Provider cache */
+    a(this, "providerCache", /* @__PURE__ */ new Map());
+    /**
+     * Chain actions (user-facing API)
+     *
+     * Access operations for each supported chain:
+     * - btc: Bitcoin operations (stake, stakeAndDeploy, deposit)
+     * - evm: EVM operations (deposit, stake, unstake, deploy, redeem)
+     * - solana: Solana operations (unstake)
+     * - sui: Sui operations (unstake)
+     * - starknet: Starknet operations (unstake)
+     */
+    a(this, "chain");
+    a(this, "assets");
+    /**
+     * API namespace for data-fetching operations
+     *
+     * Provides convenient access to Lombard API read operations:
+     * - deposits: Fetch deposit history
+     * - unstakes: Fetch unstake/redemption history
+     * - points: Fetch Lux points
+     * - exchangeRatio: Get exchange ratios for all supported tokens
+     * - depositAddress: Get existing BTC deposit address
+     */
+    a(this, "api");
+    /** Feature clients */
+    a(this, "referrals");
+    /** Capability registry (manages optional module services) */
+    a(this, "capabilities");
+    this.config = t, this.env = t.env, this.partnerConfig = new _(t.partner), this.capabilities = new S(
+      this.config.modules,
+      this.config
+    ), this.chain = {
+      btc: new Ct(this.config),
+      evm: new Et(this.config),
+      solana: new G(this.config),
+      sui: new j(this.config),
+      starknet: new V(this.config)
+    }, this.referrals = new lt(this), this.assets = new Zt(this.env), this.api = new xt(this.env);
+  }
+  async getProvider(t) {
+    const e = t;
+    if (this.providerCache.has(e))
+      return this.providerCache.get(e);
+    const n = D(this.config.providers, t);
+    if (!n)
+      throw d.providerMissing(t, t);
+    const r = await n();
+    if (!r)
+      throw new d(
+        ct.PROVIDER_INITIALIZATION_FAILED,
+        `Failed to initialize ${t} provider`
+      );
+    return this.providerCache.set(e, r), r;
+  }
+  /**
+   * Configure partner settings
+   *
+   * @param config - Partner configuration
+   */
+  configure(t) {
+    this.partnerConfig.update(t);
+  }
+  /**
+   * Register a custom asset
+   *
+   * TODO: Implement asset registration
+   */
+  registerAsset(t) {
+    throw new Error("Not implemented yet");
+  }
+  /**
+   * Get partner configuration
+   */
+  getPartnerConfig() {
+    return this.partnerConfig;
+  }
+  getPartnerId() {
+    return this.partnerConfig.getPartnerId();
+  }
+}
+const N = /* @__PURE__ */ new Map();
+function Qt(s) {
+  return N.has(s) || N.set(s, Promise.resolve(b)), N.get(s);
+}
+async function Ae(s) {
+  const t = "modules" in s && Array.isArray(s.modules) ? s : Bt(s), e = await Qt(t.env), n = {
+    ...t,
+    catalog: e
+  };
+  return new Jt(n);
+}
+function Ie(s) {
+  return typeof s == "object" && s !== null && "request" in s && typeof s.request == "function";
+}
+function Se(s) {
+  return typeof s == "object" && s !== null && "getAddresses" in s && typeof s.getAddresses == "function";
+}
+function _e(s) {
+  return typeof s == "object" && s !== null && "publicKey" in s && "signAndSendTransaction" in s;
+}
+function De(s) {
+  return typeof s == "object" && s !== null && "getAddress" in s && "signAndExecuteTransactionBlock" in s;
+}
+function Ne(s) {
+  return typeof s == "object" && s !== null && "address" in s && "execute" in s;
+}
+const Te = {
+  /** Progress update with detailed step information */
+  Progress: "progress",
+  /** Status change (e.g., 'idle' → 'preparing' → 'ready') */
+  StatusChange: "status-change",
+  /** Operation completed successfully */
+  Completed: "completed",
+  /** Operation failed */
+  Failed: "failed",
+  /** Error occurred */
+  Error: "error"
+}, xe = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+}, Pe = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+}, we = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+}, be = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+}, ye = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+};
+export {
+  xt as ApiNamespace,
+  ye as BridgeEvent,
+  be as DeployEvent,
+  xe as DepositEvent,
+  Jt as LombardSDK,
+  Pe as RedeemEvent,
+  G as SolanaActions,
+  Te as StakeEvent,
+  V as StarknetActions,
+  j as SuiActions,
+  we as UnstakeEvent,
+  Bt as createConfig,
+  Tt as createConsoleLogger,
+  Ae as createLombardSDK,
+  me as createSilentLogger,
+  ve as getSdkHeaders,
+  Se as isBtcProvider,
+  Ie as isEvmProvider,
+  _e as isSolanaProvider,
+  Ne as isStarknetProvider,
+  De as isSuiProvider,
+  Ce as solanaActions,
+  fe as starknetActions,
+  Ee as suiActions
+};
+//# sourceMappingURL=events-DAiXVdGv.js.map