@lombard.finance/sdk 4.1.0 → 4.2.0

package/dist/chunks/EvmActions-MW5mNmqs.js

@@ -0,0 +1,1351 @@
+var tt = Object.defineProperty;
+var et = (n, a, t) => a in n ? tt(n, a, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[a] = t;
+var u = (n, a, t) => et(n, typeof a != "symbol" ? a + "" : a, t);
+import w from "bignumber.js";
+import { d as G, o as U, h as st, p as at, s as it, k as rt, r as z, j as nt, i as ot, l as ct } from "./unstakeLBTC-Huy_ncVl.js";
+import { T as l, V as W, e as $, G as ht, f as Y } from "./token-addresses-DmAr89jP.js";
+import { C as _, y as P, E as e, z as S, L as c, X as E, q as i, A as x, Y as ut, Z as L, _ as Z, $ as I, x as K, a0 as j, a1 as b, a2 as pt } from "./statusConstants-ZJia15m2.js";
+import { e as V, m as O, t as y, g as M, f as q } from "./tokens-Bw35TZqd.js";
+import { g as dt, s as mt } from "./storeNetworkFeeSignature-BZUZOxns.js";
+import { r as vt } from "./fee-requirements-x8-8mpJ7.js";
+import { D as T, A as m } from "./defi-registry-dhrQMy94.js";
+import { r } from "./index-CfcQ_g3t.js";
+import { t as Q } from "./numbers-CM-lcmt4.js";
+import { c as B, a as D, b as X } from "./config-_8X_2sG4.js";
+import { d as lt, c as Et, q as _t } from "./withdraw-CVNVJ7-x.js";
+class Ct {
+  constructor(a) {
+    this.env = a;
+  }
+  /**
+   * Get minting fee for a chain
+   * @param chainId - The chain ID
+   * @param token - Optional token (defaults to LBTC). Use Token.BTCb for BTC.b deposits.
+   */
+  async getMintingFee(a, t) {
+    return (await G({
+      token: t || l.LBTC,
+      chainId: a,
+      env: this.env
+    })).toString();
+  }
+  /**
+   * Sign network fee authorization (EIP-712)
+   */
+  async signNetworkFee(a) {
+    const t = await U({
+      fee: new w(a.fee),
+      account: a.account,
+      chainId: a.chainId,
+      provider: a.provider,
+      env: this.env,
+      // Pass token for signing - defaults to LBTC for backwards compatibility
+      token: a.token ?? l.LBTC
+    });
+    return {
+      signature: t.signature,
+      typedData: t.typedData
+    };
+  }
+  /**
+   * Get stake and bake fee for a vault
+   */
+  async getStakeAndBakeFee(a, t) {
+    return (await st({
+      chainId: a,
+      protocol: t
+    })).toString();
+  }
+  /**
+   * Sign stake and bake authorization
+   */
+  async signStakeAndBake(a) {
+    const t = await at({
+      value: new w(a.value),
+      account: a.account,
+      chainId: a.chainId,
+      provider: a.provider,
+      env: this.env,
+      vaultKey: a.vaultKey,
+      token: a.token
+    });
+    return {
+      signature: t.signature,
+      typedData: t.typedData
+    };
+  }
+  /**
+   * Sign LBTC destination address (for non-Ethereum EVM chains)
+   */
+  async signLbtcDestination(a) {
+    return { signature: await it({
+      account: a.address,
+      chainId: a.chainId,
+      provider: a.provider
+    }) };
+  }
+}
+function ue() {
+  return {
+    id: "evm",
+    chain: "evm",
+    register(n) {
+      return new Ct(n.env);
+    }
+  };
+}
+const gt = {
+  routes: [
+    // Veda - Ethereum
+    {
+      asset: m.LBTC,
+      sourceChains: [_.ETHEREUM],
+      protocols: [T.Veda],
+      envs: [r.prod]
+    },
+    // Veda - Base
+    {
+      asset: m.LBTC,
+      sourceChains: [_.BASE],
+      protocols: [T.Veda],
+      envs: [r.prod]
+    },
+    // Veda - BSC
+    {
+      asset: m.LBTC,
+      sourceChains: [_.BSC],
+      protocols: [T.Veda],
+      envs: [r.prod]
+    },
+    // Veda - Corn
+    {
+      asset: m.LBTC,
+      sourceChains: [_.CORN],
+      protocols: [T.Veda],
+      envs: [r.prod]
+    },
+    // Silo - Avalanche
+    {
+      asset: m.LBTC,
+      sourceChains: [_.AVALANCHE],
+      protocols: [T.Silo],
+      envs: [r.prod]
+    }
+  ]
+};
+class At extends P {
+  constructor(t, s) {
+    super(e.IDLE);
+    u(this, "_amount");
+    u(this, "_protocol");
+    u(this, "_needsApproval", !1);
+    u(this, "_txHash");
+    u(this, "_account");
+    u(this, "_chainId");
+    this.ctx = t, this.params = s;
+  }
+  get amount() {
+    return this._amount;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  get needsApproval() {
+    return this._needsApproval;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare(t) {
+    return this.assertStatus(e.IDLE, "prepare"), this.act(async () => {
+      const s = S(this.prepareSchema, t);
+      this._amount = s.amount, this._protocol = t.protocol, this.validateProtocol(t.protocol);
+      const o = await this.ctx.getProvider("evm");
+      if (!o)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const p = (await o.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!p)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      this._account = p, this._chainId = E(this.params.sourceChain);
+      const v = B[D.Veda], h = await V(l.LBTC, this._chainId, this.ctx.env);
+      if (!h)
+        throw c.invalidParameter("token", "Could not get LBTC token info");
+      const C = await O({ chainId: this._chainId }).readContract({
+        address: h.address,
+        abi: h.abi,
+        functionName: "allowance",
+        args: [p, v.vaultContract.address]
+      }), f = new w(s.amount), N = y(f, h.decimals), R = new w(String(C));
+      this._needsApproval = N.isGreaterThan(R), this._needsApproval ? (this.emitProgress({
+        status: e.NEEDS_APPROVAL,
+        steps: { approval: i.PENDING, deploying: i.IDLE }
+      }), this.updateStatus(e.NEEDS_APPROVAL)) : (this.emitProgress({
+        status: e.READY,
+        steps: { approval: i.COMPLETE, deploying: i.PENDING }
+      }), this.updateStatus(e.READY));
+    });
+  }
+  async approve() {
+    return this.assertStatus(e.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      if (!this._account || !this._chainId || !this._amount)
+        throw c.missingParameter("account, chainId, or amount");
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const s = B[D.Veda], o = await V(l.LBTC, this._chainId, this.ctx.env);
+      if (!o)
+        throw c.invalidParameter("token", "Could not get LBTC token info");
+      const d = new w(this._amount), p = Q(y(d, o.decimals)), v = O({ chainId: this._chainId }), h = W({
+        provider: t,
+        chainId: this._chainId
+      }), { request: A } = await v.simulateContract({
+        account: this._account,
+        chain: $[this._chainId],
+        address: o.address,
+        abi: o.abi,
+        functionName: "approve",
+        args: [s.vaultContract.address, p]
+      });
+      await h.writeContract(A), this._needsApproval = !1, this.emitProgress({
+        status: e.READY,
+        steps: { approval: i.COMPLETE, deploying: i.PENDING }
+      });
+    }, e.READY);
+  }
+  async execute() {
+    return this.assertStatus(e.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      if (!this._account || !this._chainId)
+        throw c.missingParameter("account or chainId");
+      const s = this._protocol === "veda" ? D.Veda : D.Veda;
+      this.emitProgress({
+        status: e.READY,
+        steps: { approval: i.COMPLETE, deploying: i.PENDING }
+      });
+      const o = await lt({
+        amount: this._amount,
+        approve: !1,
+        // Approval was handled in approve() step
+        token: l.LBTC,
+        vaultKey: s,
+        account: this._account,
+        chainId: this._chainId,
+        provider: t,
+        env: this.ctx.env
+      });
+      return this._txHash = o, this.emitProgress({
+        status: e.COMPLETED,
+        steps: { approval: i.COMPLETE, deploying: i.COMPLETE }
+      }), this.emitCompleted(), { txHash: o };
+    }, e.COMPLETED);
+  }
+  get prepareSchema() {
+    return x({
+      amount: L,
+      protocol: ut().min(1, "Protocol is required")
+    });
+  }
+  validateProtocol(t) {
+    if (!gt.routes.some(
+      (o) => o.protocols.includes(t) && o.envs.includes(this.ctx.env)
+    ))
+      throw c.invalidParameter(
+        "protocol",
+        `Protocol ${t} is not supported in ${this.ctx.env} environment`
+      );
+  }
+}
+function It(n, a) {
+  return new At(n, a);
+}
+const ft = [
+  .../* @__PURE__ */ new Set([
+    ...I(m.WBTC, [r.prod]),
+    ...I(m.BTCb, [r.prod])
+  ])
+], Dt = [
+  .../* @__PURE__ */ new Set([
+    ...I(m.WBTC, [r.testnet, r.stage, r.dev, r.ibc]),
+    ...I(m.BTCb, [r.testnet, r.stage, r.dev, r.ibc])
+  ])
+], wt = I(m.LBTC, [r.prod]), Pt = I(m.LBTC, [
+  r.testnet,
+  r.stage,
+  r.dev,
+  r.ibc
+]), Tt = {
+  routes: [
+    // Production: WBTC/BTCb → LBTC
+    {
+      assetsIn: [m.WBTC, m.BTCb],
+      assetOut: m.LBTC,
+      sourceChains: ft,
+      destChains: wt,
+      envs: [r.prod]
+    },
+    // Testnet
+    {
+      assetsIn: [m.WBTC, m.BTCb],
+      assetOut: m.LBTC,
+      sourceChains: Dt,
+      destChains: Pt,
+      envs: [r.testnet, r.stage, r.dev, r.ibc]
+    }
+  ],
+  addressSchema: Z
+};
+var g = /* @__PURE__ */ ((n) => (n.IDLE = "idle", n.NEEDS_APPROVAL = "needs-approval", n.READY = "ready", n.BRIDGING = "bridging", n.COMPLETED = "completed", n))(g || {});
+class St extends P {
+  constructor(t, s) {
+    super(g.IDLE);
+    u(this, "_amount");
+    u(this, "_recipient");
+    u(this, "_needsApproval", !1);
+    u(this, "_txHash");
+    u(this, "_claimData");
+    this.ctx = t, this.params = s;
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get needsApproval() {
+    return this._needsApproval;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  setClaimData(t, s) {
+    this._claimData = { data: t, proofSignature: s };
+  }
+  async prepare(t) {
+    return this.assertStatus(g.IDLE, "prepare"), this.act(async () => {
+      const s = S(this.prepareSchema, t, {
+        destChain: this.params.destChain
+      });
+      this._amount = s.amount, this._recipient = s.recipient, this._needsApproval = !1, this.emitProgress({
+        status: g.READY,
+        steps: {
+          approval: i.COMPLETE,
+          execution: i.IDLE,
+          bridging: i.IDLE
+        }
+      });
+    }, g.READY);
+  }
+  async approve() {
+    return this.assertStatus(g.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      this._needsApproval = !1;
+    }, g.READY);
+  }
+  async execute() {
+    if (this.assertStatus(g.READY, "execute"), !this._claimData)
+      throw c.missingParameter("claimData");
+    return this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const s = E(this.params.destChain);
+      this.emitProgress({
+        status: g.READY,
+        steps: {
+          approval: i.COMPLETE,
+          execution: i.PENDING,
+          bridging: i.IDLE
+        }
+      });
+      const o = await rt({
+        provider: t,
+        account: this._recipient,
+        data: this._claimData.data,
+        proofSignature: this._claimData.proofSignature,
+        chainId: s,
+        env: this.ctx.env
+      });
+      return this._txHash = o, this.emitProgress({
+        status: g.COMPLETED,
+        steps: {
+          approval: i.COMPLETE,
+          execution: i.COMPLETE,
+          bridging: i.IDLE
+        }
+      }), this.emitCompleted(), { txHash: o };
+    }, g.COMPLETED);
+  }
+  get prepareSchema() {
+    return x({
+      amount: L,
+      recipient: Tt.addressSchema
+    });
+  }
+}
+function xt(n, a) {
+  return new St(n, a);
+}
+const Lt = I(m.BTCb, [r.prod]), Nt = I(m.BTCb, [
+  r.testnet,
+  r.stage,
+  r.dev,
+  r.ibc
+]), Ot = {
+  routes: [
+    // BTC.b → BTC (to Bitcoin Mainnet)
+    {
+      assetIn: m.BTCb,
+      assetOut: m.BTC,
+      sourceChains: Lt,
+      destChain: _.BITCOIN_MAINNET,
+      envs: [r.prod]
+    },
+    // BTC.b → BTC (to Bitcoin Signet - testnet)
+    {
+      assetIn: m.BTCb,
+      assetOut: m.BTC,
+      sourceChains: Nt,
+      destChain: _.BITCOIN_SIGNET,
+      envs: [r.testnet, r.stage, r.dev, r.ibc]
+    }
+    // TODO: Add L-Asset routes when deployed
+    // L-ZEC → ZEC, L-SOL → SOL, L-XRP → XRP, L-DOGE → DOGE
+  ],
+  recipientSchema: K
+};
+async function k(n, a, t, s) {
+  if (!vt(n))
+    return {
+      requiresAuth: !1,
+      hasValidSignature: !1,
+      feeInSatoshis: null,
+      feeFormatted: null,
+      expirationDate: null
+    };
+  const o = await M(s, n, t), d = await dt({
+    address: a,
+    chainId: n,
+    env: t,
+    tokenAddress: o.address
+  }), p = d.expirationDate ? new Date(Number(d.expirationDate) * 1e3) < /* @__PURE__ */ new Date() : !1, v = d.hasSignature && !p;
+  let h = null, A = null;
+  if (!v) {
+    const C = await G({
+      token: s,
+      chainId: n,
+      env: t
+    });
+    h = BigInt(C.times(1e8).toFixed(0)), A = C.toFixed(8);
+  }
+  return {
+    requiresAuth: !0,
+    hasValidSignature: v,
+    feeInSatoshis: h,
+    feeFormatted: A,
+    expirationDate: d.expirationDate ?? null
+  };
+}
+async function H(n) {
+  const { chainId: a, account: t, feeInSatoshis: s, provider: o, env: d, token: p } = n, v = await M(p, a, d), h = await U({
+    fee: s,
+    account: t,
+    chainId: a,
+    provider: o,
+    env: d,
+    token: p
+  });
+  return await mt({
+    signature: h.signature,
+    typedData: h.typedData,
+    address: t,
+    env: d,
+    tokenAddress: v.address
+  }), h;
+}
+function F() {
+  return {
+    requiresAuth: !1,
+    isAuthorized: !1,
+    feeInSatoshis: null,
+    feeFormatted: null,
+    expirationDate: null
+  };
+}
+class Bt extends P {
+  constructor(t, s) {
+    super(e.IDLE);
+    u(this, "_amount");
+    u(this, "_recipient");
+    u(this, "_needsApproval", !1);
+    u(this, "_txHash");
+    u(this, "_feeAuth", F());
+    this.ctx = t, this.params = s;
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get needsApproval() {
+    return this._needsApproval;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  /** Fee authorization state (for UI display) */
+  get feeAuth() {
+    return this._feeAuth;
+  }
+  async prepare(t) {
+    return this.assertStatus(e.IDLE, "prepare"), this.act(async () => {
+      const s = S(this.prepareSchema, t, {
+        destChain: this.params.destChain
+      });
+      this._amount = s.amount, this._recipient = s.recipient;
+      const o = E(this.params.sourceChain), d = await this.ctx.getProvider("evm");
+      if (!d)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const v = (await d.request({
+        method: "eth_accounts"
+      }))[0], h = await k(
+        o,
+        v,
+        this.ctx.env,
+        l.BTCb
+      );
+      if (this._feeAuth = {
+        requiresAuth: h.requiresAuth,
+        isAuthorized: h.hasValidSignature,
+        feeInSatoshis: h.feeInSatoshis,
+        feeFormatted: h.feeFormatted,
+        expirationDate: h.expirationDate
+      }, h.requiresAuth && !h.hasValidSignature) {
+        this.emitProgress({
+          status: e.NEEDS_FEE_AUTHORIZATION,
+          steps: { burning: i.IDLE, releasing: i.IDLE }
+        });
+        return;
+      }
+      this._needsApproval = !1, this.emitProgress({
+        status: e.READY,
+        steps: { burning: i.IDLE, releasing: i.IDLE }
+      });
+    }, this._feeAuth.requiresAuth && !this._feeAuth.isAuthorized ? e.NEEDS_FEE_AUTHORIZATION : e.READY);
+  }
+  /**
+   * Authorize the network fee
+   *
+   * Must be called when status is NEEDS_FEE_AUTHORIZATION.
+   * Signs the fee authorization and stores it on the server.
+   */
+  async authorizeFee() {
+    if (this.assertStatus(e.NEEDS_FEE_AUTHORIZATION, "authorizeFee"), !this._feeAuth.feeInSatoshis)
+      throw c.missingParameter("feeInSatoshis");
+    return this.act(async () => {
+      const t = E(this.params.sourceChain), s = await this.ctx.getProvider("evm");
+      if (!s)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const d = (await s.request({
+        method: "eth_accounts"
+      }))[0];
+      await H({
+        chainId: t,
+        account: d,
+        feeInSatoshis: this._feeAuth.feeInSatoshis,
+        provider: s,
+        env: this.ctx.env,
+        token: l.BTCb
+      }), this._feeAuth.isAuthorized = !0, this.emitProgress({
+        status: e.READY,
+        steps: { burning: i.IDLE, releasing: i.IDLE }
+      });
+    }, e.READY);
+  }
+  async approve() {
+    return this.assertStatus(e.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      this._needsApproval = !1, this.emitProgress({
+        status: e.READY,
+        steps: { burning: i.IDLE, releasing: i.IDLE }
+      });
+    }, e.READY);
+  }
+  async execute() {
+    return this.assertStatus(e.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const o = (await t.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!o)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const d = E(this.params.sourceChain);
+      this.emitProgress({
+        status: e.READY,
+        steps: { burning: i.PENDING, releasing: i.IDLE }
+      });
+      const p = await z({
+        provider: t,
+        account: o,
+        amount: this._amount,
+        btcAddress: this._recipient,
+        // Bitcoin address to receive BTC
+        chainId: d,
+        env: this.ctx.env,
+        tokenIn: l.BTCb,
+        tokenOut: void 0
+        // Native BTC output
+      });
+      return this._txHash = p, this.emitProgress({
+        status: e.COMPLETED,
+        steps: { burning: i.COMPLETE, releasing: i.PENDING }
+      }), this.emitCompleted(), { txHash: p };
+    }, e.COMPLETED);
+  }
+  get prepareSchema() {
+    return x({
+      amount: L,
+      recipient: Ot.recipientSchema
+    });
+  }
+}
+function Rt(n, a) {
+  return new Bt(n, a);
+}
+const bt = [
+  Y.avalanche,
+  Y.avalancheFuji
+];
+function yt(n) {
+  return bt.includes(n);
+}
+class Mt extends P {
+  constructor(t, s) {
+    super(e.IDLE);
+    u(this, "_amount");
+    u(this, "_txHash");
+    u(this, "_feeAuth", F());
+    u(this, "_account");
+    u(this, "_needsApproval", !1);
+    u(this, "_spenderAddress");
+    this.ctx = t, this.params = s;
+  }
+  get amount() {
+    return this._amount;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  /** Fee authorization state (for UI display) */
+  get feeAuth() {
+    return this._feeAuth;
+  }
+  /** Whether approval is needed */
+  get needsApproval() {
+    return this._needsApproval;
+  }
+  async prepare(t) {
+    return this.assertStatus(e.IDLE, "prepare"), this.act(async () => {
+      const s = S(this.prepareSchema, t);
+      this._amount = s.amount;
+      const o = await this.ctx.getProvider("evm");
+      if (!o)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const p = (await o.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!p)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      this._account = p;
+      const v = E(this.params.sourceChain);
+      if (yt(v)) {
+        const C = await M(
+          l.BTCb,
+          v,
+          this.ctx.env,
+          ht.Adapter
+        );
+        this._spenderAddress = C.address;
+        const f = await nt({
+          token: l.BTCb,
+          owner: p,
+          spender: C.address,
+          chainId: v,
+          env: this.ctx.env
+        }), N = new w(s.amount);
+        if (this._needsApproval = f.isLessThan(N), this._needsApproval) {
+          this.emitProgress({
+            status: e.NEEDS_APPROVAL,
+            steps: { approval: i.PENDING, staking: i.IDLE }
+          }), this.updateStatus(e.NEEDS_APPROVAL);
+          return;
+        }
+      }
+      const h = await k(
+        v,
+        p,
+        this.ctx.env,
+        l.LBTC
+      );
+      this._feeAuth = {
+        requiresAuth: h.requiresAuth,
+        isAuthorized: h.hasValidSignature,
+        feeInSatoshis: h.feeInSatoshis,
+        feeFormatted: h.feeFormatted,
+        expirationDate: h.expirationDate
+      }, h.requiresAuth && !h.hasValidSignature ? (this.emitProgress({
+        status: e.NEEDS_FEE_AUTHORIZATION,
+        steps: { staking: i.IDLE }
+      }), this.updateStatus(e.NEEDS_FEE_AUTHORIZATION)) : (this.emitProgress({
+        status: e.READY,
+        steps: { staking: i.PENDING }
+      }), this.updateStatus(e.READY));
+    });
+  }
+  /**
+   * Approve BTC.b spending (Avalanche only)
+   *
+   * Must be called when status is NEEDS_APPROVAL.
+   */
+  async approve() {
+    return this.assertStatus(e.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      if (!this._account || !this._spenderAddress || !this._amount)
+        throw c.missingParameter(
+          "account, spenderAddress, or amount"
+        );
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const s = E(this.params.sourceChain);
+      await ot({
+        account: this._account,
+        token: l.BTCb,
+        spender: this._spenderAddress,
+        amount: this._amount,
+        chainId: s,
+        provider: t,
+        env: this.ctx.env
+      }), this._needsApproval = !1, this.emitProgress({
+        status: e.READY,
+        steps: { approval: i.COMPLETE, staking: i.PENDING }
+      });
+    }, e.READY);
+  }
+  async authorizeFee() {
+    return this.assertStatus(
+      e.NEEDS_FEE_AUTHORIZATION,
+      "authorizeFee"
+    ), this.act(async () => {
+      if (!this._feeAuth.feeInSatoshis)
+        throw c.missingParameter("feeInSatoshis");
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const s = E(this.params.sourceChain);
+      await H({
+        chainId: s,
+        account: this._account,
+        feeInSatoshis: this._feeAuth.feeInSatoshis,
+        provider: t,
+        env: this.ctx.env,
+        token: l.LBTC
+        // BTC.b → LBTC uses LBTC token for fee signature
+      }), this._feeAuth = {
+        ...this._feeAuth,
+        isAuthorized: !0
+      }, this.emitProgress({
+        status: e.READY,
+        steps: { staking: i.PENDING }
+      });
+    }, e.READY);
+  }
+  async execute() {
+    return this.assertStatus(e.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const s = E(this.params.sourceChain), d = (await t.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!d)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      this.emitProgress({
+        status: e.READY,
+        steps: { staking: i.PENDING }
+      });
+      const p = await ct({
+        amount: this._amount,
+        tokenIn: l.BTCb,
+        tokenOut: l.LBTC,
+        account: d,
+        chainId: s,
+        provider: t,
+        env: this.ctx.env
+      });
+      return this._txHash = p, this.emitProgress({
+        status: e.COMPLETED,
+        steps: { staking: i.COMPLETE }
+      }), this.emitCompleted(), { txHash: p };
+    }, e.COMPLETED);
+  }
+  get prepareSchema() {
+    return x({
+      amount: L
+    });
+  }
+}
+function kt(n, a) {
+  return new Mt(n, a);
+}
+const Ht = I(m.LBTC, [r.prod]), Ft = I(m.LBTC, [
+  r.testnet,
+  r.stage,
+  r.dev,
+  r.ibc
+]), Yt = j(
+  [m.LBTC, m.BTCb],
+  [r.prod]
+), Vt = j(
+  [m.LBTC, m.BTCb],
+  [r.testnet, r.stage, r.dev, r.ibc]
+), qt = {
+  routes: [
+    // Production: EVM chains with LBTC → Bitcoin Mainnet
+    {
+      sourceChains: Ht,
+      destChain: _.BITCOIN_MAINNET,
+      envs: [r.prod]
+    },
+    // Testnet: EVM chains with LBTC → Bitcoin Signet
+    {
+      sourceChains: Ft,
+      destChain: _.BITCOIN_SIGNET,
+      envs: [r.testnet, r.stage, r.dev, r.ibc]
+    }
+  ],
+  recipientSchema: K
+}, Gt = {
+  routes: [
+    // Production: Same-chain routes for chains with both LBTC and BTCb
+    ...Yt.map((n) => ({
+      sourceChains: [n],
+      destChain: n,
+      envs: [r.prod]
+    })),
+    // Testnet: Same-chain routes
+    ...Vt.map((n) => ({
+      sourceChains: [n],
+      destChain: n,
+      envs: [r.testnet, r.stage, r.dev, r.ibc]
+    }))
+  ],
+  recipientSchema: Z
+};
+class Ut extends P {
+  constructor(t, s) {
+    super(e.IDLE);
+    u(this, "_amount");
+    u(this, "_recipient");
+    u(this, "_txHash");
+    u(this, "_feeAuth", F());
+    this.ctx = t, this.params = s;
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  /** Fee authorization state (for UI display) */
+  get feeAuth() {
+    return this._feeAuth;
+  }
+  /** Whether output is BTC.b (requires fee auth on unsubsidized chains) */
+  get isBtcbOutput() {
+    return this.params.assetOut === m.BTCb;
+  }
+  async prepare(t) {
+    return this.assertStatus(e.IDLE, "prepare"), this.act(async () => {
+      const s = S(this.prepareSchema, t, {
+        destChain: this.params.destChain
+      });
+      this._amount = s.amount, this._recipient = s.recipient;
+      const o = E(this.params.sourceChain);
+      if (this.isBtcbOutput) {
+        const d = await this.ctx.getProvider("evm");
+        if (!d)
+          throw c.providerMissing(this.params.sourceChain, "evm");
+        const v = (await d.request({
+          method: "eth_accounts"
+        }))[0], h = await k(
+          o,
+          v,
+          this.ctx.env,
+          l.BTCb
+        );
+        if (this._feeAuth = {
+          requiresAuth: h.requiresAuth,
+          isAuthorized: h.hasValidSignature,
+          feeInSatoshis: h.feeInSatoshis,
+          feeFormatted: h.feeFormatted,
+          expirationDate: h.expirationDate
+        }, h.requiresAuth && !h.hasValidSignature) {
+          this.emitProgress({
+            status: e.NEEDS_FEE_AUTHORIZATION,
+            steps: { burning: i.IDLE, releasing: i.IDLE }
+          });
+          return;
+        }
+      }
+      this.emitProgress({
+        status: e.READY,
+        steps: { burning: i.IDLE, releasing: i.IDLE }
+      });
+    }, this._feeAuth.requiresAuth && !this._feeAuth.isAuthorized ? e.NEEDS_FEE_AUTHORIZATION : e.READY);
+  }
+  /**
+   * Authorize the network fee
+   *
+   * Must be called when status is NEEDS_FEE_AUTHORIZATION.
+   * Signs the fee authorization and stores it on the server.
+   */
+  async authorizeFee() {
+    if (this.assertStatus(e.NEEDS_FEE_AUTHORIZATION, "authorizeFee"), !this._feeAuth.feeInSatoshis)
+      throw c.missingParameter("feeInSatoshis");
+    return this.act(async () => {
+      const t = E(this.params.sourceChain), s = await this.ctx.getProvider("evm");
+      if (!s)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const d = (await s.request({
+        method: "eth_accounts"
+      }))[0];
+      await H({
+        chainId: t,
+        account: d,
+        feeInSatoshis: this._feeAuth.feeInSatoshis,
+        provider: s,
+        env: this.ctx.env,
+        token: l.BTCb
+      }), this._feeAuth.isAuthorized = !0, this.emitProgress({
+        status: e.READY,
+        steps: { burning: i.IDLE, releasing: i.IDLE }
+      });
+    }, e.READY);
+  }
+  async execute() {
+    return this.assertStatus(e.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const o = (await t.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!o)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const d = E(this.params.sourceChain), p = this.params.assetOut === m.BTCb;
+      this.emitProgress({
+        status: e.READY,
+        steps: { burning: i.PENDING, releasing: i.IDLE }
+      });
+      const v = await z({
+        provider: t,
+        account: p ? this._recipient : o,
+        amount: this._amount,
+        btcAddress: p ? void 0 : this._recipient,
+        chainId: d,
+        env: this.ctx.env,
+        tokenIn: l.LBTC,
+        tokenOut: p ? l.BTCb : void 0
+      });
+      return this._txHash = v, this.emitProgress({
+        status: e.COMPLETED,
+        steps: {
+          burning: i.COMPLETE,
+          releasing: p ? i.COMPLETE : i.PENDING
+        }
+      }), this.emitCompleted(), { txHash: v };
+    }, e.COMPLETED);
+  }
+  get prepareSchema() {
+    const t = this.params.assetOut === m.BTC ? qt : Gt;
+    return x({
+      amount: L,
+      recipient: t.recipientSchema
+    });
+  }
+}
+function zt(n, a) {
+  return new Ut(n, a);
+}
+const J = {
+  routes: [
+    // Veda - Ethereum, Base, BSC, Corn
+    {
+      sourceChains: [_.ETHEREUM, _.BASE, _.BSC, _.CORN],
+      protocols: [T.Veda],
+      envs: [r.prod]
+    }
+  ]
+};
+class Wt extends P {
+  constructor(t, s) {
+    super(e.IDLE);
+    u(this, "_txHash");
+    u(this, "_account");
+    u(this, "_chainId");
+    this.ctx = t, this.params = s;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare() {
+    return this.assertStatus(e.IDLE, "prepare"), this.act(async () => {
+      this.validateProtocol(this.params.protocol);
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.chain, "evm");
+      const o = (await t.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!o)
+        throw c.providerMissing(this.params.chain, "evm");
+      if (this._account = o, this._chainId = E(this.params.chain), !X(this._chainId))
+        throw new c(
+          b.PROTOCOL_NOT_SUPPORTED,
+          `Chain ${this.params.chain} does not support Veda vault withdrawals`,
+          { chain: this.params.chain, protocol: this.params.protocol }
+        );
+      this.emitProgress({
+        status: e.READY,
+        steps: { cancelling: i.PENDING }
+      }), this.updateStatus(e.READY);
+    });
+  }
+  async execute() {
+    return this.assertStatus(e.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.chain, "evm");
+      if (!this._account || !this._chainId)
+        throw c.missingParameter("account or chainId");
+      this.emitProgress({
+        status: e.READY,
+        steps: { cancelling: i.PENDING }
+      });
+      const s = await Et({
+        vaultKey: D.Veda,
+        account: this._account,
+        chainId: this._chainId,
+        provider: t,
+        env: this.ctx.env
+      });
+      return this._txHash = s, this.emitProgress({
+        status: e.COMPLETED,
+        steps: { cancelling: i.COMPLETE }
+      }), this.emitCompleted(), { txHash: s };
+    }, e.COMPLETED);
+  }
+  validateProtocol(t) {
+    if (!J.routes.some(
+      (o) => o.protocols.includes(t) && o.envs.includes(this.ctx.env)
+    ))
+      throw c.invalidParameter(
+        "protocol",
+        `Protocol ${t} is not supported for withdrawals in ${this.ctx.env} environment`
+      );
+  }
+}
+class $t extends P {
+  constructor(t, s) {
+    super(e.IDLE);
+    u(this, "_amount");
+    u(this, "_protocol");
+    u(this, "_needsApproval", !1);
+    u(this, "_txHash");
+    u(this, "_account");
+    u(this, "_chainId");
+    this.ctx = t, this.params = s;
+  }
+  get amount() {
+    return this._amount;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  get needsApproval() {
+    return this._needsApproval;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare(t) {
+    return this.assertStatus(e.IDLE, "prepare"), this.act(async () => {
+      const s = S(this.prepareSchema, t);
+      this._amount = s.amount, this._protocol = this.params.protocol, this.validateProtocol(this.params.protocol);
+      const o = await this.ctx.getProvider("evm");
+      if (!o)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const p = (await o.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!p)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      if (this._account = p, this._chainId = E(this.params.sourceChain), !X(this._chainId))
+        throw new c(
+          b.PROTOCOL_NOT_SUPPORTED,
+          `Chain ${this.params.sourceChain} does not support Veda vault withdrawals`,
+          { chain: this.params.sourceChain, protocol: this._protocol }
+        );
+      const v = B[D.Veda], h = O({ chainId: this._chainId }), A = await h.readContract({
+        address: v.lensContract.address,
+        abi: v.lensContract.abi,
+        functionName: "balanceOf",
+        args: [p, v.vaultContract.address]
+      }), C = q(String(A), v.decimals), f = new w(s.amount);
+      if (f.isGreaterThan(C))
+        throw new c(
+          b.INSUFFICIENT_SHARES,
+          `Insufficient vault shares. Requested: ${f.toFixed()}, Available: ${C.toFixed()}`,
+          { requested: f.toFixed(), available: C.toFixed() }
+        );
+      const N = await h.readContract({
+        address: v.vaultContract.address,
+        abi: v.vaultContract.abi,
+        functionName: "allowance",
+        args: [p, v.withdrawQueueContracts[this._chainId].address]
+      }), R = q(String(N), v.decimals);
+      this._needsApproval = f.isGreaterThan(R), this._needsApproval ? (this.emitProgress({
+        status: e.NEEDS_APPROVAL,
+        steps: { approval: i.PENDING, queueing: i.IDLE }
+      }), this.updateStatus(e.NEEDS_APPROVAL)) : (this.emitProgress({
+        status: e.READY,
+        steps: { approval: i.COMPLETE, queueing: i.PENDING }
+      }), this.updateStatus(e.READY));
+    });
+  }
+  async approve() {
+    return this.assertStatus(e.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      if (!this._account || !this._chainId || !this._amount)
+        throw c.missingParameter("account, chainId, or amount");
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      const s = B[D.Veda], o = new w(this._amount), d = Q(y(o, s.decimals)), p = O({ chainId: this._chainId }), v = W({
+        provider: t,
+        chainId: this._chainId
+      }), h = this._chainId, { request: A } = await p.simulateContract({
+        account: this._account,
+        chain: $[this._chainId],
+        address: s.vaultContract.address,
+        abi: s.vaultContract.abi,
+        functionName: "approve",
+        args: [s.withdrawQueueContracts[h].address, d]
+      });
+      await v.writeContract(A), this._needsApproval = !1, this.emitProgress({
+        status: e.READY,
+        steps: { approval: i.COMPLETE, queueing: i.PENDING }
+      });
+    }, e.READY);
+  }
+  async execute() {
+    return this.assertStatus(e.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw c.providerMissing(this.params.sourceChain, "evm");
+      if (!this._account || !this._chainId || !this._amount)
+        throw c.missingParameter("account, chainId, or amount");
+      this.emitProgress({
+        status: e.READY,
+        steps: { approval: i.COMPLETE, queueing: i.PENDING }
+      });
+      const s = await _t({
+        amount: this._amount,
+        approve: !1,
+        vaultKey: D.Veda,
+        account: this._account,
+        chainId: this._chainId,
+        provider: t,
+        env: this.ctx.env
+      });
+      return this._txHash = s, this.emitProgress({
+        status: e.COMPLETED,
+        steps: { approval: i.COMPLETE, queueing: i.COMPLETE }
+      }), this.emitCompleted(), { txHash: s };
+    }, e.COMPLETED);
+  }
+  get prepareSchema() {
+    return x({
+      amount: L
+    });
+  }
+  validateProtocol(t) {
+    if (!J.routes.some(
+      (o) => o.protocols.includes(t) && o.envs.includes(this.ctx.env)
+    ))
+      throw c.invalidParameter(
+        "protocol",
+        `Protocol ${t} is not supported for withdrawals in ${this.ctx.env} environment`
+      );
+  }
+}
+function Zt(n, a) {
+  return new $t(n, a);
+}
+function Kt(n, a) {
+  return new Wt(n, a);
+}
+class jt {
+  constructor(a) {
+    u(this, "ctx");
+    this.ctx = pt(a);
+  }
+  /**
+   * Stake BTC.b to receive LBTC
+   *
+   * Converts wrapped BTC (BTC.b) to LBTC via the Asset Router.
+   * Currently supported on Avalanche.
+   *
+   * @example
+   * ```typescript
+   * const stake = evm.stake({
+   *   assetIn: AssetId.BTCb,
+   *   assetOut: AssetId.LBTC,
+   *   sourceChain: Chain.AVALANCHE,
+   *   destChain: Chain.AVALANCHE,
+   * });
+   * ```
+   */
+  stake(a) {
+    return kt(this.ctx, a);
+  }
+  /**
+   * Unstake LBTC to BTC or BTC.b
+   *
+   * - LBTC → BTC: Cross-chain to Bitcoin mainnet/signet
+   * - LBTC → BTC.b: Same-chain wrapped BTC on EVM
+   *
+   * @example
+   * ```typescript
+   * const unstake = evm.unstake({
+   *   assetIn: AssetId.LBTC,
+   *   assetOut: AssetId.BTC,
+   *   sourceChain: Chain.ETHEREUM,
+   *   destChain: Chain.BITCOIN_MAINNET,
+   * });
+   * ```
+   */
+  unstake(a) {
+    return zt(this.ctx, a);
+  }
+  /**
+   * Deposit wrapped BTC to get LBTC
+   *
+   * Deposits WBTC or BTCb to receive LBTC.
+   *
+   * @example
+   * ```typescript
+   * const deposit = evm.deposit({
+   *   assetIn: AssetId.WBTC,
+   *   assetOut: AssetId.LBTC,
+   *   sourceChain: Chain.ETHEREUM,
+   *   destChain: Chain.ETHEREUM,
+   * });
+   * ```
+   */
+  deposit(a) {
+    return xt(this.ctx, a);
+  }
+  /**
+   * Deploy L-Assets to DeFi protocols
+   *
+   * Currently supports Veda and Silo protocols.
+   *
+   * @example
+   * ```typescript
+   * const deploy = evm.deploy({
+   *   asset: AssetId.LBTC,
+   *   sourceChain: Chain.ETHEREUM,
+   *   protocol: DeployProtocol.Veda,
+   *   recipient: '0x...',
+   * });
+   * ```
+   */
+  deploy(a) {
+    return It(this.ctx, a);
+  }
+  /**
+   * Withdraw vault shares from DeFi protocols
+   *
+   * Queues a withdrawal request from DeFi protocols (e.g., Veda vault).
+   * After the withdrawal is queued, it will be processed within the
+   * protocol's withdrawal window.
+   *
+   * @example
+   * ```typescript
+   * const withdraw = evm.withdraw({
+   *   protocol: DeployProtocol.Veda,
+   *   sourceChain: Chain.ETHEREUM,
+   *   recipient: '0x...',
+   * });
+   * await withdraw.prepare({ amount: '0.1' });
+   * if (withdraw.needsApproval) await withdraw.approve();
+   * await withdraw.execute();
+   * ```
+   */
+  withdraw(a) {
+    return Zt(this.ctx, a);
+  }
+  /**
+   * Cancel a pending withdrawal from DeFi protocols
+   *
+   * Cancels a previously queued withdrawal request.
+   *
+   * @example
+   * ```typescript
+   * const cancelWithdraw = evm.cancelWithdraw({
+   *   protocol: DeployProtocol.Veda,
+   *   chain: Chain.ETHEREUM,
+   * });
+   * await cancelWithdraw.prepare();
+   * await cancelWithdraw.execute();
+   * ```
+   */
+  cancelWithdraw(a) {
+    return Kt(this.ctx, a);
+  }
+  /**
+   * Redeem LBTC to BTC.b (same-chain unwrap)
+   *
+   * Converts LBTC to BTC.b on the same EVM chain.
+   * For cross-chain BTC redemption, use unstake() with destChain set to Bitcoin.
+   *
+   * @example
+   * ```typescript
+   * const redeem = evm.redeem({
+   *   assetIn: AssetId.LBTC,
+   *   assetOut: AssetId.BTCb,
+   *   sourceChain: Chain.AVALANCHE,
+   * });
+   * ```
+   */
+  redeem(a) {
+    return Rt(this.ctx, a);
+  }
+}
+function pe(n) {
+  return new jt(n);
+}
+export {
+  jt as E,
+  ue as a,
+  g as b,
+  pe as e
+};
+//# sourceMappingURL=EvmActions-MW5mNmqs.js.map