@lombard.finance/sdk 4.6.0 → 4.7.0

package/dist/chunks/events-LMs7IA1e.js

@@ -1,1108 +0,0 @@
-var F = Object.defineProperty;
-var U = (t, e, s) => e in t ? F(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
-var a = (t, e, s) => U(t, typeof e != "symbol" ? e + "" : e, s);
-import "axios";
-import { SDK_RUNTIME as G, SDK_VERSION as Y, LombardError as g, bitcoinAddressSchema as v, Chain as d, BaseAction as f, NonEvmUnstakeStatus as r, validatePrepareParams as C, StepStatus as o, objectType as E, amountSchema as I, CapabilityRegistry as S, PartnerConfiguration as A, getProviderGetter as D, ASSET_CATALOG as x, getAssetAddress as K, getAssetDecimals as V, getAssetMetadata as j, usesAssetRouter as $, getAssetRouter as q, getBridgeAdapter as z, getPublicMarketMaker as W, getAssetByAddress as X, isAssetDeployed as Z, getAssetChains as J, getAssetEnvironments as Q, getSupportedAssets as ee, ProviderErrorCode as te } from "./statusConstants-BU4PglPs.js";
-import { generateDepositBtcAddress as se } from "./getUserStakeAndBakeSignature-Su-k10ap.js";
-import { getDepositsByAddress as P, getUnstakesByAddress as ne, getPointsByAddress as re, getDepositBtcAddress as N, storeStakeAndBakeSignature as ie, ReferralsClient as ae } from "./ReferralsClient-AxhLoWRT.js";
-import { storeNetworkFeeSignature as oe, getNetworkFeeSignature as ce } from "./storeNetworkFeeSignature-BODIpq3Y.js";
-import { btcModule as ue, BtcActions as he } from "./BtcActions-CI5XotUx.js";
-import { evmModule as de, EvmActions as ge } from "./EvmActions-C7EKF3jb.js";
-import { toSatoshi as b } from "./satoshi-CSoJBXc6.js";
-import { p as k, r as u } from "./index-CfcQ_g3t.js";
-import { AssetId as w } from "./defi-registry-ig-wro_O.js";
-import { getExchangeRatio as le } from "./get-exchange-ratio-B-xzYND1.js";
-import { Vault as pe } from "./config-JT3GvwPB.js";
-import { getVaultWithdrawals as me, getVaultWithdrawalsAllChains as ve } from "./get-vault-withdrawals-CQwNiILS.js";
-const y = ["debug", "info", "warn", "error", "none"];
-function fe(t = {}) {
-  const { level: e = "debug", prefix: s = "[Lombard SDK]", timestamp: n = !1 } = t, i = y.indexOf(e), c = (h) => y.indexOf(h) >= i && e !== "none", l = (h) => {
-    if (n) {
-      const p = (/* @__PURE__ */ new Date()).toISOString();
-      return `${s} ${p} ${h}`;
-    }
-    return `${s} ${h}`;
-  }, m = (h) => !h || Object.keys(h).length === 0 ? [] : [h];
-  return {
-    debug(h, p) {
-      c("debug") && console.debug(l(h), ...m(p));
-    },
-    info(h, p) {
-      c("info") && console.info(l(h), ...m(p));
-    },
-    warn(h, p) {
-      c("warn") && console.warn(l(h), ...m(p));
-    },
-    error(h, p) {
-      c("error") && console.error(l(h), ...m(p));
-    }
-  };
-}
-function rt() {
-  return {
-    debug: () => {
-    },
-    info: () => {
-    },
-    warn: () => {
-    },
-    error: () => {
-    }
-  };
-}
-function it() {
-  return {
-    "X-SDK-Version": Y,
-    "X-SDK-Runtime": G
-  };
-}
-class Ce {
-  constructor(e = k) {
-    /**
-     * Internal API version flag for future v2 migration.
-     * When v2 is ready, we can switch implementations transparently.
-     */
-    a(this, "apiVersion", "v1");
-    this.env = e;
-  }
-  /* -------------------------------------------------------------------------- */
-  /*                               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(e) {
-    return P({ address: e, 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(e, s) {
-    return ne({ address: e, env: this.env, options: s });
-  }
-  async points(e, s) {
-    return re({ address: e, env: this.env, season: s });
-  }
-  /* -------------------------------------------------------------------------- */
-  /*                          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 le({ 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(e, s, n) {
-    return N({
-      address: e,
-      chainId: s,
-      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(e, s) {
-    const n = e, i = (s == null ? void 0 : s.vault) ?? pe.Veda;
-    return s != null && s.chainId ? me({
-      account: n,
-      chainId: s.chainId,
-      vaultKey: i,
-      rpcUrl: s.rpcUrl,
-      env: this.env
-    }) : ve({
-      account: n,
-      vaultKey: i,
-      rpcUrl: s == null ? void 0 : s.rpcUrl
-    });
-  }
-  /* -------------------------------------------------------------------------- */
-  /*                            Utility Methods                                 */
-  /* -------------------------------------------------------------------------- */
-  /**
-   * Get the current API version being used.
-   *
-   * @returns The API version string ('v1' or 'v2')
-   */
-  getApiVersion() {
-    return this.apiVersion;
-  }
-}
-function Ee(t) {
-  if (!t.env)
-    throw g.missingParameter("env");
-  const e = {
-    env: t.env,
-    providers: t.providers || {}
-  };
-  return t.partner && (Ie(t.partner), e.partner = t.partner), e;
-}
-function Ie(t) {
-  if (typeof t != "object" || t === null)
-    throw g.invalidConfiguration(
-      "Partner configuration must be an object"
-    );
-  const e = t;
-  if (!e.partnerId || typeof e.partnerId != "string")
-    throw g.missingParameter("partner.partnerId");
-  if (e.partnerId.trim().length === 0)
-    throw g.invalidConfiguration("Partner ID cannot be empty");
-}
-class Se {
-  constructor(e) {
-    this.env = e;
-  }
-  /**
-   * Generate a new BTC deposit address
-   */
-  async generateDepositAddress(e) {
-    return se({
-      address: e.address,
-      chainId: e.chainId,
-      signature: e.signature,
-      token: e.token,
-      eip712Data: e.eip712Data,
-      signatureData: e.signatureData,
-      pubKey: e.pubKey,
-      env: this.env,
-      partnerId: e.partnerId,
-      referrerCode: e.referrerCode,
-      captchaToken: e.captchaToken
-    });
-  }
-  /**
-   * Get existing deposit address for a recipient
-   */
-  async getDepositAddress(e) {
-    try {
-      return await N({
-        address: e.address,
-        chainId: e.chainId,
-        token: e.token,
-        env: this.env,
-        partnerId: e.partnerId
-      }) || void 0;
-    } catch {
-      return;
-    }
-  }
-  /**
-   * Get deposits for an address
-   */
-  async getDeposits(e) {
-    return (await P({
-      address: e,
-      env: this.env
-    })).map((n) => {
-      var i;
-      return {
-        depositAddress: n.depositAddress ?? "",
-        blockHeight: n.blockHeight,
-        isClaimed: n.isClaimed,
-        txid: n.txHash,
-        amount: (i = n.amount) == null ? void 0 : i.toString()
-      };
-    });
-  }
-  /**
-   * Store network fee signature
-   */
-  async storeFeeSignature(e) {
-    await oe({
-      address: e.address,
-      signature: e.signature,
-      typedData: e.typedData,
-      env: this.env,
-      tokenAddress: e.tokenAddress
-    });
-  }
-  /**
-   * Get stored network fee signature
-   */
-  async getFeeSignature(e) {
-    return ce({
-      address: e.address,
-      chainId: e.chainId,
-      env: this.env,
-      tokenAddress: e.tokenAddress
-    });
-  }
-  /**
-   * Store stake and bake signature
-   */
-  async storeStakeAndBakeSignature(e) {
-    await ie({
-      signature: e.signature,
-      typedData: e.typedData,
-      env: this.env
-    });
-  }
-}
-function Ae() {
-  return {
-    id: "api",
-    register(t) {
-      return new Se(t.env);
-    }
-  };
-}
-function De(t) {
-  const e = /* @__PURE__ */ new Map(), s = [ue(), de(), Ae()];
-  for (const n of s)
-    e.set(n.id, n);
-  if (t)
-    for (const n of t)
-      e.set(n.id, n);
-  return Array.from(e.values());
-}
-function _e(t, e) {
-  for (const s of t)
-    for (const n of s.requiresProviders ?? [])
-      if (!we(e, n))
-        throw g.providerMissing(n, n);
-}
-function we(t, e) {
-  var s;
-  return !!((s = t.providers) != null && s[e]);
-}
-function ye(t) {
-  const e = Ee(t), s = De(
-    t.modules
-  );
-  _e(s, e);
-  let n = t.logger;
-  return !n && t.debug && (n = fe({ level: "debug" })), {
-    ...e,
-    modules: s,
-    logger: n
-  };
-}
-function xe(t) {
-  switch (t) {
-    case "prod":
-      return "mainnet-beta";
-    case "testnet":
-      return "testnet";
-    case "stage":
-    case "dev":
-    case "ibc":
-    default:
-      return "devnet";
-  }
-}
-const T = {
-  routes: [
-    {
-      sourceChains: [d.SOLANA_DEVNET],
-      destChain: d.BITCOIN_SIGNET,
-      assetIn: w.BTCb,
-      assetOut: w.BTC,
-      envs: [u.stage, u.dev]
-    }
-  ],
-  recipientSchema: v
-};
-function Pe(t, e, s, n, i) {
-  return T.routes.some(
-    (c) => c.sourceChains.includes(t) && c.destChain === e && c.assetIn === s && c.assetOut === n && c.envs.includes(i)
-  );
-}
-class Ne extends f {
-  constructor(s, n) {
-    super(r.IDLE);
-    a(this, "_amount");
-    a(this, "_recipient");
-    a(this, "_txHash");
-    a(this, "env");
-    if (this.ctx = s, this.params = n, this.env = s.env, !Pe(
-      n.sourceChain,
-      n.destChain,
-      n.assetIn,
-      n.assetOut,
-      this.env
-    ))
-      throw g.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(s) {
-    return this.assertStatus(r.IDLE, "prepare"), this.act(async () => {
-      const n = C(this.prepareSchema, s, {
-        destChain: this.params.destChain
-      });
-      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
-        status: r.READY,
-        steps: { burning: o.IDLE, releasing: o.IDLE }
-      });
-    }, r.READY);
-  }
-  async execute() {
-    return this.assertStatus(r.READY, "execute"), this.act(async () => {
-      const s = this._amount, n = this._recipient;
-      if (!s || !n)
-        throw g.missingParameter("amount or recipient");
-      this.emitProgress({
-        status: r.READY,
-        steps: { burning: o.PENDING, releasing: o.IDLE }
-      });
-      const i = b(s).toString(), c = xe(this.env), { txHash: l } = await this.ctx.solana.redeemForBtc({
-        amount: i,
-        btcAddress: n,
-        network: c,
-        env: this.env
-      });
-      return this._txHash = l, this.emitProgress({
-        status: r.CONFIRMING,
-        steps: { burning: o.COMPLETE, releasing: o.PENDING }
-      }), { txHash: l };
-    }, r.CONFIRMING);
-  }
-  get prepareSchema() {
-    return E({
-      amount: I,
-      recipient: T.recipientSchema
-    });
-  }
-}
-const L = {
-  routes: [
-    // Production: Solana Mainnet → Bitcoin Mainnet
-    {
-      sourceChains: [d.SOLANA_MAINNET],
-      destChain: d.BITCOIN_MAINNET,
-      envs: [u.prod]
-    },
-    // Testnet: Solana Devnet → Bitcoin Signet
-    {
-      sourceChains: [d.SOLANA_DEVNET],
-      destChain: d.BITCOIN_SIGNET,
-      envs: [u.testnet, u.stage, u.dev, u.ibc]
-    }
-  ],
-  recipientSchema: v
-};
-function be(t, e) {
-  return L.routes.some(
-    (s) => s.sourceChains.includes(t) && s.envs.includes(e)
-  );
-}
-function ke(t) {
-  switch (t) {
-    case "prod":
-      return "mainnet-beta";
-    case "testnet":
-      return "testnet";
-    case "stage":
-    case "dev":
-    case "ibc":
-    default:
-      return "devnet";
-  }
-}
-class Te extends f {
-  constructor(s, n) {
-    super(r.IDLE);
-    a(this, "_amount");
-    a(this, "_recipient");
-    a(this, "_txHash");
-    a(this, "env");
-    if (this.ctx = s, this.params = n, this.env = s.env, !be(n.sourceChain, this.env))
-      throw g.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(s) {
-    return this.assertStatus(r.IDLE, "prepare"), this.act(async () => {
-      const n = C(this.prepareSchema, s, {
-        destChain: this.params.destChain
-      });
-      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
-        status: r.READY,
-        steps: { burning: o.IDLE, releasing: o.IDLE }
-      });
-    }, r.READY);
-  }
-  async execute() {
-    return this.assertStatus(r.READY, "execute"), this.act(async () => {
-      const s = this._amount, n = this._recipient;
-      if (!s || !n)
-        throw g.missingParameter("amount or recipient");
-      this.emitProgress({
-        status: r.READY,
-        steps: { burning: o.PENDING, releasing: o.IDLE }
-      });
-      const i = b(s).toString(), c = ke(this.env), { txHash: l } = await this.ctx.solana.unstake({
-        amount: i,
-        btcAddress: n,
-        network: c
-      });
-      return this._txHash = l, this.emitProgress({
-        status: r.COMPLETED,
-        steps: { burning: o.COMPLETE, releasing: o.PENDING }
-      }), this.emitCompleted(), { txHash: l };
-    }, r.COMPLETED);
-  }
-  get prepareSchema() {
-    return E({
-      amount: I,
-      recipient: L.recipientSchema
-    });
-  }
-}
-function Le(t) {
-  const s = new S(t.modules, t).require("solana");
-  return {
-    env: t.env,
-    partner: new A(t.partner),
-    getProvider: async (n) => {
-      const i = D(t.providers, n);
-      if (i)
-        return i();
-    },
-    solana: s
-  };
-}
-class O {
-  constructor(e) {
-    a(this, "_ctx", null);
-    this.config = e;
-  }
-  get ctx() {
-    return this._ctx || (this._ctx = Le(this.config)), this._ctx;
-  }
-  /**
-   * Unstake LBTC → BTC
-   *
-   * Burns LBTC on Solana and releases BTC on Bitcoin.
-   *
-   * @throws LombardError if solana module is not registered
-   */
-  unstake(e) {
-    return new Te(this.ctx, e);
-  }
-  /**
-   * Redeem BTC.b → BTC
-   *
-   * Burns BTC.b on Solana and releases BTC to a Bitcoin address via GMP.
-   *
-   * @throws LombardError if solana module is not registered
-   * @throws LombardError if route is not supported
-   */
-  redeem(e) {
-    return new Ne(this.ctx, e);
-  }
-}
-function at(t) {
-  return new O(t);
-}
-const M = {
-  routes: [
-    {
-      sourceChains: [d.STARKNET_MAINNET],
-      destChain: d.BITCOIN_MAINNET,
-      envs: [u.prod]
-    },
-    {
-      sourceChains: [d.STARKNET_SEPOLIA],
-      destChain: d.BITCOIN_SIGNET,
-      envs: [u.testnet, u.stage, u.dev, u.ibc]
-    }
-  ],
-  recipientSchema: v
-};
-function Oe(t, e) {
-  return M.routes.some(
-    (s) => s.sourceChains.includes(t) && s.envs.includes(e)
-  );
-}
-class Me extends f {
-  constructor(s, n) {
-    super(r.IDLE);
-    a(this, "_amount");
-    a(this, "_recipient");
-    a(this, "_txHash");
-    a(this, "env");
-    if (this.ctx = s, this.params = n, this.env = s.env, !Oe(n.sourceChain, this.env))
-      throw g.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(s) {
-    return this.assertStatus(r.IDLE, "prepare"), this.act(async () => {
-      const n = C(this.prepareSchema, s, {
-        destChain: this.params.destChain
-      });
-      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
-        status: r.READY,
-        steps: { burning: o.IDLE, releasing: o.IDLE }
-      });
-    }, r.READY);
-  }
-  async execute() {
-    return this.assertStatus(r.READY, "execute"), this.act(async () => {
-      const s = this._amount, n = this._recipient;
-      if (!s || !n)
-        throw g.missingParameter("amount or recipient");
-      this.emitProgress({
-        status: r.READY,
-        steps: { burning: o.PENDING, releasing: o.IDLE }
-      });
-      const { txHash: i } = await this.ctx.starknet.unstake({
-        amount: s,
-        btcAddress: n,
-        env: this.env
-      });
-      return this._txHash = i, this.emitProgress({
-        status: r.COMPLETED,
-        steps: { burning: o.COMPLETE, releasing: o.PENDING }
-      }), this.emitCompleted(), { txHash: i };
-    }, r.COMPLETED);
-  }
-  get prepareSchema() {
-    return E({
-      amount: I,
-      recipient: M.recipientSchema
-    });
-  }
-}
-function Re(t) {
-  const s = new S(t.modules, t).require("starknet");
-  return {
-    env: t.env,
-    partner: new A(t.partner),
-    getProvider: async (n) => {
-      const i = D(t.providers, n);
-      if (i)
-        return i();
-    },
-    starknet: s
-  };
-}
-class R {
-  constructor(e) {
-    a(this, "_ctx", null);
-    this.config = e;
-  }
-  get ctx() {
-    return this._ctx || (this._ctx = Re(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(e) {
-    return new Me(this.ctx, e);
-  }
-}
-function ot(t) {
-  return new R(t);
-}
-const B = {
-  routes: [
-    {
-      sourceChains: [d.SUI_MAINNET],
-      destChain: d.BITCOIN_MAINNET,
-      envs: [u.prod]
-    },
-    {
-      sourceChains: [d.SUI_TESTNET],
-      destChain: d.BITCOIN_SIGNET,
-      envs: [u.testnet, u.stage, u.dev, u.ibc]
-    }
-  ],
-  recipientSchema: v
-};
-function Be(t, e) {
-  return B.routes.some(
-    (s) => s.sourceChains.includes(t) && s.envs.includes(e)
-  );
-}
-function He(t) {
-  switch (t) {
-    case d.SUI_MAINNET:
-      return "sui:mainnet";
-    case d.SUI_TESTNET:
-      return "sui:testnet";
-    default:
-      return "sui:testnet";
-  }
-}
-class Fe extends f {
-  constructor(s, n) {
-    super(r.IDLE);
-    a(this, "_amount");
-    a(this, "_recipient");
-    a(this, "_txHash");
-    a(this, "env");
-    if (this.ctx = s, this.params = n, this.env = s.env, !Be(n.sourceChain, this.env))
-      throw g.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(s) {
-    return this.assertStatus(r.IDLE, "prepare"), this.act(async () => {
-      const n = C(this.prepareSchema, s, {
-        destChain: this.params.destChain
-      });
-      this._amount = n.amount, this._recipient = n.recipient, this.emitProgress({
-        status: r.READY,
-        steps: { burning: o.IDLE, releasing: o.IDLE }
-      });
-    }, r.READY);
-  }
-  async execute() {
-    return this.assertStatus(r.READY, "execute"), this.act(async () => {
-      const s = this._amount, n = this._recipient;
-      if (!s || !n)
-        throw g.missingParameter("amount or recipient");
-      this.emitProgress({
-        status: r.READY,
-        steps: { burning: o.PENDING, releasing: o.IDLE }
-      });
-      const i = He(this.params.sourceChain), { txHash: c } = await this.ctx.sui.unstake({
-        amount: s,
-        btcAddress: n,
-        chainId: i,
-        env: this.env
-      });
-      return this._txHash = c, this.emitProgress({
-        status: r.COMPLETED,
-        steps: { burning: o.COMPLETE, releasing: o.PENDING }
-      }), this.emitCompleted(), { txHash: c };
-    }, r.COMPLETED);
-  }
-  get prepareSchema() {
-    return E({
-      amount: I,
-      recipient: B.recipientSchema
-    });
-  }
-}
-function Ue(t) {
-  const s = new S(t.modules, t).require("sui");
-  return {
-    env: t.env,
-    partner: new A(t.partner),
-    getProvider: async (n) => {
-      const i = D(t.providers, n);
-      if (i)
-        return i();
-    },
-    sui: s
-  };
-}
-class H {
-  constructor(e) {
-    a(this, "_ctx", null);
-    this.config = e;
-  }
-  get ctx() {
-    return this._ctx || (this._ctx = Ue(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(e) {
-    return new Fe(this.ctx, e);
-  }
-}
-function ct(t) {
-  return new H(t);
-}
-class Ge {
-  constructor(e = k, s) {
-    a(this, "catalog");
-    this.env = e, this.catalog = s ?? x;
-  }
-  /** Get token contract address */
-  getAddress(e, s) {
-    return K(e, this.env, s, this.catalog);
-  }
-  /** Get token decimals */
-  getDecimals(e) {
-    return V(e, this.catalog);
-  }
-  /** Get asset metadata (decimals, symbol, name) */
-  getMetadata(e) {
-    return j(e, this.catalog);
-  }
-  /** Check if asset uses an asset router contract */
-  usesAssetRouter(e, s) {
-    return $(e, this.env, s, this.catalog);
-  }
-  /** Get asset router contract address */
-  getAssetRouter(e, s) {
-    return q(e, this.env, s, this.catalog);
-  }
-  /** Get bridge adapter address */
-  getBridgeAdapter(e, s) {
-    return z(e, this.env, s, this.catalog);
-  }
-  /** Get public market maker address */
-  getPublicMarketMaker(e, s) {
-    return W(e, this.env, s, this.catalog);
-  }
-  /** Find asset by contract address (reverse lookup) */
-  getByAddress(e, s) {
-    return X(e, this.env, s, this.catalog);
-  }
-  /** Check if asset is deployed on a chain */
-  isDeployed(e, s) {
-    return Z(e, this.env, s, this.catalog);
-  }
-  /** Get all chains where asset is deployed */
-  getChains(e) {
-    return J(e, this.env, this.catalog);
-  }
-  /** Get all environments where asset is deployed on a chain */
-  getEnvironments(e, s) {
-    return Q(e, s, this.catalog);
-  }
-  /** Get all supported assets */
-  getSupportedAssets() {
-    return ee(this.catalog);
-  }
-  /** Direct access to the asset catalog */
-  getCatalog() {
-    return this.catalog;
-  }
-}
-class Ye {
-  constructor(e) {
-    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 = e, this.env = e.env, this.partnerConfig = new A(e.partner), this.capabilities = new S(
-      this.config.modules,
-      this.config
-    ), this.chain = {
-      btc: new he(this.config),
-      evm: new ge(this.config),
-      solana: new O(this.config),
-      sui: new H(this.config),
-      starknet: new R(this.config)
-    }, this.referrals = new ae(this), this.assets = new Ge(this.env), this.api = new Ce(this.env);
-  }
-  async getProvider(e) {
-    const s = e;
-    if (this.providerCache.has(s))
-      return this.providerCache.get(s);
-    const n = D(this.config.providers, e);
-    if (!n)
-      throw g.providerMissing(e, e);
-    const i = await n();
-    if (!i)
-      throw new g(
-        te.PROVIDER_INITIALIZATION_FAILED,
-        `Failed to initialize ${e} provider`
-      );
-    return this.providerCache.set(s, i), i;
-  }
-  /**
-   * Configure partner settings
-   *
-   * @param config - Partner configuration
-   */
-  configure(e) {
-    this.partnerConfig.update(e);
-  }
-  /**
-   * Register a custom asset
-   *
-   * TODO: Implement asset registration
-   */
-  registerAsset(e) {
-    throw new Error("Not implemented yet");
-  }
-  /**
-   * Get partner configuration
-   */
-  getPartnerConfig() {
-    return this.partnerConfig;
-  }
-  getPartnerId() {
-    return this.partnerConfig.getPartnerId();
-  }
-}
-const _ = /* @__PURE__ */ new Map();
-function Ke(t) {
-  return _.has(t) || _.set(t, Promise.resolve(x)), _.get(t);
-}
-async function ut(t) {
-  const e = "modules" in t && Array.isArray(t.modules) ? t : ye(t), s = await Ke(e.env), n = {
-    ...e,
-    catalog: s
-  };
-  return new Ye(n);
-}
-function ht(t) {
-  return typeof t == "object" && t !== null && "request" in t && typeof t.request == "function";
-}
-function dt(t) {
-  return typeof t == "object" && t !== null && "getAddresses" in t && typeof t.getAddresses == "function";
-}
-function gt(t) {
-  return typeof t == "object" && t !== null && "publicKey" in t && "signAndSendTransaction" in t;
-}
-function lt(t) {
-  return typeof t == "object" && t !== null && "getAddress" in t && "signAndExecuteTransactionBlock" in t;
-}
-function pt(t) {
-  return typeof t == "object" && t !== null && "address" in t && "execute" in t;
-}
-const mt = {
-  /** 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"
-}, vt = {
-  Progress: "progress",
-  StatusChange: "status-change",
-  Completed: "completed",
-  Failed: "failed",
-  Error: "error"
-}, ft = {
-  Progress: "progress",
-  StatusChange: "status-change",
-  Completed: "completed",
-  Failed: "failed",
-  Error: "error"
-}, Ct = {
-  Progress: "progress",
-  StatusChange: "status-change",
-  Completed: "completed",
-  Failed: "failed",
-  Error: "error"
-}, Et = {
-  Progress: "progress",
-  StatusChange: "status-change",
-  Completed: "completed",
-  Failed: "failed",
-  Error: "error"
-}, It = {
-  Progress: "progress",
-  StatusChange: "status-change",
-  Completed: "completed",
-  Failed: "failed",
-  Error: "error"
-};
-export {
-  Ce as ApiNamespace,
-  It as BridgeEvent,
-  Et as DeployEvent,
-  vt as DepositEvent,
-  Ye as LombardSDK,
-  ft as RedeemEvent,
-  O as SolanaActions,
-  mt as StakeEvent,
-  R as StarknetActions,
-  H as SuiActions,
-  Ct as UnstakeEvent,
-  ye as createConfig,
-  fe as createConsoleLogger,
-  ut as createLombardSDK,
-  rt as createSilentLogger,
-  it as getSdkHeaders,
-  dt as isBtcProvider,
-  ht as isEvmProvider,
-  gt as isSolanaProvider,
-  pt as isStarknetProvider,
-  lt as isSuiProvider,
-  at as solanaActions,
-  ot as starknetActions,
-  ct as suiActions
-};
-//# sourceMappingURL=events-LMs7IA1e.js.map