@lombard.finance/sdk 4.1.0 → 4.2.0

package/dist/chunks/events-CLVUaKQS.js

@@ -0,0 +1,996 @@
+var B = Object.defineProperty;
+var R = (t, e, s) => e in t ? B(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var a = (t, e, s) => R(t, typeof e != "symbol" ? e + "" : e, s);
+import "axios";
+import { a as H, b as U, L as d, x as A, C as h, y as S, N as i, z as I, q as o, A as D, D as y, F as f, P as m, G as C, H as _, f as F, I as K, J as G, K as V, M as Y, O as j, Q as $, T as q, l as z, h as W, U as X, W as J, v as Q } from "./statusConstants-ZJia15m2.js";
+import { g as Z } from "./getUserStakeAndBakeSignature-2xPkL9v_.js";
+import { d as P, k as ee, i as te, g as x, s as se, R as re } from "./ReferralsClient-JjWLlIO4.js";
+import { s as ne, g as ae } from "./storeNetworkFeeSignature-BZUZOxns.js";
+import { a as ie, B as oe } from "./BtcActions-DGqmtxjd.js";
+import { a as ce, E as ue } from "./EvmActions-MW5mNmqs.js";
+import { t as he } from "./satoshi-Ch6y8aYG.js";
+import { p as k, r as u } from "./index-CfcQ_g3t.js";
+import { g as de } from "./get-exchange-ratio-B0CNEGOB.js";
+import { a as ge } from "./config-_8X_2sG4.js";
+import { g as le, a as pe } from "./get-vault-withdrawals-CSQqKFB8.js";
+const w = ["debug", "info", "warn", "error", "none"];
+function ve(t = {}) {
+  const { level: e = "debug", prefix: s = "[Lombard SDK]", timestamp: r = !1 } = t, n = w.indexOf(e), l = (c) => w.indexOf(c) >= n && e !== "none", p = (c) => {
+    if (r) {
+      const g = (/* @__PURE__ */ new Date()).toISOString();
+      return `${s} ${g} ${c}`;
+    }
+    return `${s} ${c}`;
+  }, v = (c) => !c || Object.keys(c).length === 0 ? [] : [c];
+  return {
+    debug(c, g) {
+      l("debug") && console.debug(p(c), ...v(g));
+    },
+    info(c, g) {
+      l("info") && console.info(p(c), ...v(g));
+    },
+    warn(c, g) {
+      l("warn") && console.warn(p(c), ...v(g));
+    },
+    error(c, g) {
+      l("error") && console.error(p(c), ...v(g));
+    }
+  };
+}
+function Qe() {
+  return {
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    }
+  };
+}
+function Ze() {
+  return {
+    "X-SDK-Version": U,
+    "X-SDK-Runtime": H
+  };
+}
+class fe {
+  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 ee({ address: e, env: this.env, options: s });
+  }
+  async points(e, s) {
+    return te({ 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 de({ 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, r) {
+    return x({
+      address: e,
+      chainId: s,
+      env: this.env,
+      partnerId: r == null ? void 0 : r.partnerId,
+      token: r == null ? void 0 : r.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 r = e, n = (s == null ? void 0 : s.vault) ?? ge.Veda;
+    return s != null && s.chainId ? le({
+      account: r,
+      chainId: s.chainId,
+      vaultKey: n,
+      rpcUrl: s.rpcUrl,
+      env: this.env
+    }) : pe({
+      account: r,
+      vaultKey: n,
+      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 me(t) {
+  if (!t.env)
+    throw d.missingParameter("env");
+  const e = {
+    env: t.env,
+    providers: t.providers || {}
+  };
+  return t.partner && (Ce(t.partner), e.partner = t.partner), e;
+}
+function Ce(t) {
+  if (typeof t != "object" || t === null)
+    throw d.invalidConfiguration(
+      "Partner configuration must be an object"
+    );
+  const e = t;
+  if (!e.partnerId || typeof e.partnerId != "string")
+    throw d.missingParameter("partner.partnerId");
+  if (e.partnerId.trim().length === 0)
+    throw d.invalidConfiguration("Partner ID cannot be empty");
+}
+class Ee {
+  constructor(e) {
+    this.env = e;
+  }
+  /**
+   * Generate a new BTC deposit address
+   */
+  async generateDepositAddress(e) {
+    return Z({
+      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
+    });
+  }
+  /**
+   * Get existing deposit address for a recipient
+   */
+  async getDepositAddress(e) {
+    try {
+      return await x({
+        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((r) => {
+      var n;
+      return {
+        depositAddress: r.depositAddress ?? "",
+        blockHeight: r.blockHeight,
+        isClaimed: r.isClaimed,
+        txid: r.txHash,
+        amount: (n = r.amount) == null ? void 0 : n.toString()
+      };
+    });
+  }
+  /**
+   * Store network fee signature
+   */
+  async storeFeeSignature(e) {
+    await ne({
+      address: e.address,
+      signature: e.signature,
+      typedData: e.typedData,
+      env: this.env,
+      tokenAddress: e.tokenAddress
+    });
+  }
+  /**
+   * Get stored network fee signature
+   */
+  async getFeeSignature(e) {
+    return ae({
+      address: e.address,
+      chainId: e.chainId,
+      env: this.env,
+      tokenAddress: e.tokenAddress
+    });
+  }
+  /**
+   * Store stake and bake signature
+   */
+  async storeStakeAndBakeSignature(e) {
+    await se({
+      signature: e.signature,
+      typedData: e.typedData,
+      env: this.env
+    });
+  }
+}
+function Ae() {
+  return {
+    id: "api",
+    register(t) {
+      return new Ee(t.env);
+    }
+  };
+}
+function Se(t) {
+  const e = /* @__PURE__ */ new Map(), s = [ie(), ce(), Ae()];
+  for (const r of s)
+    e.set(r.id, r);
+  if (t)
+    for (const r of t)
+      e.set(r.id, r);
+  return Array.from(e.values());
+}
+function Ie(t, e) {
+  for (const s of t)
+    for (const r of s.requiresProviders ?? [])
+      if (!De(e, r))
+        throw d.providerMissing(r, r);
+}
+function De(t, e) {
+  var s;
+  return !!((s = t.providers) != null && s[e]);
+}
+function ye(t) {
+  const e = me(t), s = Se(
+    t.modules
+  );
+  Ie(s, e);
+  let r = t.logger;
+  return !r && t.debug && (r = ve({ level: "debug" })), {
+    ...e,
+    modules: s,
+    logger: r
+  };
+}
+const N = {
+  routes: [
+    // Production: Solana Mainnet → Bitcoin Mainnet
+    {
+      sourceChains: [h.SOLANA_MAINNET],
+      destChain: h.BITCOIN_MAINNET,
+      envs: [u.prod]
+    },
+    // Testnet: Solana Devnet → Bitcoin Signet
+    {
+      sourceChains: [h.SOLANA_DEVNET],
+      destChain: h.BITCOIN_SIGNET,
+      envs: [u.testnet, u.stage, u.dev, u.ibc]
+    }
+  ],
+  recipientSchema: A
+};
+function we(t, e) {
+  return N.routes.some(
+    (s) => s.sourceChains.includes(t) && s.envs.includes(e)
+  );
+}
+function _e(t) {
+  switch (t) {
+    case "prod":
+      return "mainnet-beta";
+    case "testnet":
+      return "testnet";
+    case "stage":
+    case "dev":
+    case "ibc":
+    default:
+      return "devnet";
+  }
+}
+class Pe extends S {
+  constructor(s, r) {
+    super(i.IDLE);
+    a(this, "_amount");
+    a(this, "_recipient");
+    a(this, "_txHash");
+    a(this, "env");
+    if (this.ctx = s, this.params = r, this.env = s.env, !we(r.sourceChain, this.env))
+      throw d.routeNotFound({
+        assetOut: r.assetOut,
+        sourceChain: r.sourceChain,
+        destChain: r.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(i.IDLE, "prepare"), this.act(async () => {
+      const r = I(this.prepareSchema, s, {
+        destChain: this.params.destChain
+      });
+      this._amount = r.amount, this._recipient = r.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 s = this._amount, r = this._recipient;
+      if (!s || !r)
+        throw d.missingParameter("amount or recipient");
+      this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.PENDING, releasing: o.IDLE }
+      });
+      const n = he(s).toString(), l = _e(this.env), { txHash: p } = await this.ctx.solana.unstake({
+        amount: n,
+        btcAddress: r,
+        network: l
+      });
+      return this._txHash = p, this.emitProgress({
+        status: i.COMPLETED,
+        steps: { burning: o.COMPLETE, releasing: o.PENDING }
+      }), this.emitCompleted(), { txHash: p };
+    }, i.COMPLETED);
+  }
+  get prepareSchema() {
+    return D({
+      amount: y,
+      recipient: N.recipientSchema
+    });
+  }
+}
+function xe(t) {
+  const s = new f(t.modules, t).require("solana");
+  return {
+    env: t.env,
+    partner: new m(t.partner),
+    getProvider: async (r) => {
+      const n = C(t.providers, r);
+      if (n)
+        return n();
+    },
+    solana: s
+  };
+}
+class b {
+  constructor(e) {
+    a(this, "_ctx", null);
+    this.config = e;
+  }
+  get ctx() {
+    return this._ctx || (this._ctx = xe(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 Pe(this.ctx, e);
+  }
+}
+function et(t) {
+  return new b(t);
+}
+const T = {
+  routes: [
+    {
+      sourceChains: [h.STARKNET_MAINNET],
+      destChain: h.BITCOIN_MAINNET,
+      envs: [u.prod]
+    },
+    {
+      sourceChains: [h.STARKNET_SEPOLIA],
+      destChain: h.BITCOIN_SIGNET,
+      envs: [u.testnet, u.stage, u.dev, u.ibc]
+    }
+  ],
+  recipientSchema: A
+};
+function ke(t, e) {
+  return T.routes.some(
+    (s) => s.sourceChains.includes(t) && s.envs.includes(e)
+  );
+}
+class Ne extends S {
+  constructor(s, r) {
+    super(i.IDLE);
+    a(this, "_amount");
+    a(this, "_recipient");
+    a(this, "_txHash");
+    a(this, "env");
+    if (this.ctx = s, this.params = r, this.env = s.env, !ke(r.sourceChain, this.env))
+      throw d.routeNotFound({
+        assetOut: r.assetOut,
+        sourceChain: r.sourceChain,
+        destChain: r.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(i.IDLE, "prepare"), this.act(async () => {
+      const r = I(this.prepareSchema, s, {
+        destChain: this.params.destChain
+      });
+      this._amount = r.amount, this._recipient = r.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 s = this._amount, r = this._recipient;
+      if (!s || !r)
+        throw d.missingParameter("amount or recipient");
+      this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.PENDING, releasing: o.IDLE }
+      });
+      const { txHash: n } = await this.ctx.starknet.unstake({
+        amount: s,
+        btcAddress: r,
+        env: this.env
+      });
+      return this._txHash = n, this.emitProgress({
+        status: i.COMPLETED,
+        steps: { burning: o.COMPLETE, releasing: o.PENDING }
+      }), this.emitCompleted(), { txHash: n };
+    }, i.COMPLETED);
+  }
+  get prepareSchema() {
+    return D({
+      amount: y,
+      recipient: T.recipientSchema
+    });
+  }
+}
+function be(t) {
+  const s = new f(t.modules, t).require("starknet");
+  return {
+    env: t.env,
+    partner: new m(t.partner),
+    getProvider: async (r) => {
+      const n = C(t.providers, r);
+      if (n)
+        return n();
+    },
+    starknet: s
+  };
+}
+class L {
+  constructor(e) {
+    a(this, "_ctx", null);
+    this.config = e;
+  }
+  get ctx() {
+    return this._ctx || (this._ctx = be(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 Ne(this.ctx, e);
+  }
+}
+function tt(t) {
+  return new L(t);
+}
+const M = {
+  routes: [
+    {
+      sourceChains: [h.SUI_MAINNET],
+      destChain: h.BITCOIN_MAINNET,
+      envs: [u.prod]
+    },
+    {
+      sourceChains: [h.SUI_TESTNET],
+      destChain: h.BITCOIN_SIGNET,
+      envs: [u.testnet, u.stage, u.dev, u.ibc]
+    }
+  ],
+  recipientSchema: A
+};
+function Te(t, e) {
+  return M.routes.some(
+    (s) => s.sourceChains.includes(t) && s.envs.includes(e)
+  );
+}
+function Le(t) {
+  switch (t) {
+    case h.SUI_MAINNET:
+      return "sui:mainnet";
+    case h.SUI_TESTNET:
+      return "sui:testnet";
+    default:
+      return "sui:testnet";
+  }
+}
+class Me extends S {
+  constructor(s, r) {
+    super(i.IDLE);
+    a(this, "_amount");
+    a(this, "_recipient");
+    a(this, "_txHash");
+    a(this, "env");
+    if (this.ctx = s, this.params = r, this.env = s.env, !Te(r.sourceChain, this.env))
+      throw d.routeNotFound({
+        assetOut: r.assetOut,
+        sourceChain: r.sourceChain,
+        destChain: r.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(i.IDLE, "prepare"), this.act(async () => {
+      const r = I(this.prepareSchema, s, {
+        destChain: this.params.destChain
+      });
+      this._amount = r.amount, this._recipient = r.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 s = this._amount, r = this._recipient;
+      if (!s || !r)
+        throw d.missingParameter("amount or recipient");
+      this.emitProgress({
+        status: i.READY,
+        steps: { burning: o.PENDING, releasing: o.IDLE }
+      });
+      const n = Le(this.params.sourceChain), { txHash: l } = await this.ctx.sui.unstake({
+        amount: s,
+        btcAddress: r,
+        chainId: n,
+        env: this.env
+      });
+      return this._txHash = l, this.emitProgress({
+        status: i.COMPLETED,
+        steps: { burning: o.COMPLETE, releasing: o.PENDING }
+      }), this.emitCompleted(), { txHash: l };
+    }, i.COMPLETED);
+  }
+  get prepareSchema() {
+    return D({
+      amount: y,
+      recipient: M.recipientSchema
+    });
+  }
+}
+function Oe(t) {
+  const s = new f(t.modules, t).require("sui");
+  return {
+    env: t.env,
+    partner: new m(t.partner),
+    getProvider: async (r) => {
+      const n = C(t.providers, r);
+      if (n)
+        return n();
+    },
+    sui: s
+  };
+}
+class O {
+  constructor(e) {
+    a(this, "_ctx", null);
+    this.config = e;
+  }
+  get ctx() {
+    return this._ctx || (this._ctx = Oe(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 Me(this.ctx, e);
+  }
+}
+function st(t) {
+  return new O(t);
+}
+class Be {
+  constructor(e = k, s) {
+    a(this, "catalog");
+    this.env = e, this.catalog = s ?? _;
+  }
+  /** Get token contract address */
+  getAddress(e, s) {
+    return F(e, this.env, s, this.catalog);
+  }
+  /** Get token decimals */
+  getDecimals(e) {
+    return K(e, this.catalog);
+  }
+  /** Get asset metadata (decimals, symbol, name) */
+  getMetadata(e) {
+    return G(e, this.catalog);
+  }
+  /** Check if asset uses an asset router contract */
+  usesAssetRouter(e, s) {
+    return V(e, this.env, s, this.catalog);
+  }
+  /** Get asset router contract address */
+  getAssetRouter(e, s) {
+    return Y(e, this.env, s, this.catalog);
+  }
+  /** Get bridge adapter address */
+  getBridgeAdapter(e, s) {
+    return j(e, this.env, s, this.catalog);
+  }
+  /** Get public market maker address */
+  getPublicMarketMaker(e, s) {
+    return $(e, this.env, s, this.catalog);
+  }
+  /** Find asset by contract address (reverse lookup) */
+  getByAddress(e, s) {
+    return q(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 W(e, this.env, this.catalog);
+  }
+  /** Get all environments where asset is deployed on a chain */
+  getEnvironments(e, s) {
+    return X(e, s, this.catalog);
+  }
+  /** Get all supported assets */
+  getSupportedAssets() {
+    return J(this.catalog);
+  }
+  /** Direct access to the asset catalog */
+  getCatalog() {
+    return this.catalog;
+  }
+}
+class Re {
+  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 m(e.partner), this.capabilities = new f(
+      this.config.modules,
+      this.config
+    ), this.chain = {
+      btc: new oe(this.config),
+      evm: new ue(this.config),
+      solana: new b(this.config),
+      sui: new O(this.config),
+      starknet: new L(this.config)
+    }, this.referrals = new re(this), this.assets = new Be(this.env), this.api = new fe(this.env);
+  }
+  async getProvider(e) {
+    const s = e;
+    if (this.providerCache.has(s))
+      return this.providerCache.get(s);
+    const r = C(this.config.providers, e);
+    if (!r)
+      throw d.providerMissing(e, e);
+    const n = await r();
+    if (!n)
+      throw new d(
+        Q.PROVIDER_INITIALIZATION_FAILED,
+        `Failed to initialize ${e} provider`
+      );
+    return this.providerCache.set(s, n), n;
+  }
+  /**
+   * 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 E = /* @__PURE__ */ new Map();
+function He(t) {
+  return E.has(t) || E.set(t, Promise.resolve(_)), E.get(t);
+}
+async function rt(t) {
+  const e = "modules" in t && Array.isArray(t.modules) ? t : ye(t), s = await He(e.env), r = {
+    ...e,
+    catalog: s
+  };
+  return new Re(r);
+}
+function nt(t) {
+  return typeof t == "object" && t !== null && "request" in t && typeof t.request == "function";
+}
+function at(t) {
+  return typeof t == "object" && t !== null && "getAddresses" in t && typeof t.getAddresses == "function";
+}
+function it(t) {
+  return typeof t == "object" && t !== null && "publicKey" in t && "signAndSendTransaction" in t;
+}
+function ot(t) {
+  return typeof t == "object" && t !== null && "getAddress" in t && "signAndExecuteTransactionBlock" in t;
+}
+function ct(t) {
+  return typeof t == "object" && t !== null && "address" in t && "execute" in t;
+}
+const ut = {
+  /** 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"
+}, ht = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+}, dt = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+}, gt = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+}, lt = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+}, pt = {
+  Progress: "progress",
+  StatusChange: "status-change",
+  Completed: "completed",
+  Failed: "failed",
+  Error: "error"
+};
+export {
+  fe as A,
+  pt as B,
+  lt as D,
+  Re as L,
+  dt as R,
+  b as S,
+  gt as U,
+  Qe as a,
+  ye as b,
+  ve as c,
+  rt as d,
+  L as e,
+  tt as f,
+  Ze as g,
+  O as h,
+  st as i,
+  at as j,
+  nt as k,
+  it as l,
+  ct as m,
+  ot as n,
+  ht as o,
+  ut as p,
+  et as s
+};
+//# sourceMappingURL=events-CLVUaKQS.js.map