@lombard.finance/sdk 4.7.1 → 5.0.0

package/dist/chunks/EvmActions-DSKThOAy.js

@@ -1,1341 +0,0 @@
-var et = Object.defineProperty;
-var st = (r, a, t) => a in r ? et(r, a, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[a] = t;
-var u = (r, a, t) => st(r, typeof a != "symbol" ? a + "" : a, t);
-import D from "bignumber.js";
-import { getMintingFee as U, signNetworkFee as z, getStakeAndBakeFee as at, signStakeAndBake as it, signLbtcDestinationAddr as rt, waitForTransactionReceipt as M, claimLBTC as nt, redeemToken as $, getTokenAllowance as ot, approveToken as ct, depositToken as ht } from "./unstakeLBTC-Bg8OsAMV.js";
-import { Token as l, makeWalletClient as W, CHAIN_ID_TO_VIEM_CHAIN_MAP as Z, AddressKind as ut, ChainId as V } from "./token-addresses-Ddar0FyS.js";
-import { getTokenInfo as q, makePublicClient as O, toBaseDenomination as b, getTokenContractInfo as H, fromBaseDenomination as G } from "./tokens-HhVpKe3K.js";
-import { Chain as C, BaseAction as P, EvmOperationStatus as e, validatePrepareParams as S, LombardError as c, parseChainIdentifier as _, StepStatus as i, objectType as x, evmAmountSchema as L, stringType as pt, evmAddressSchema as K, getEvmAssetChains as w, bitcoinAddressSchema as Q, getEvmChainsWithAllAssets as j, WithdrawErrorCode as y, createEvmCoreContext as dt } from "./statusConstants-BQna5LGH.js";
-import { getNetworkFeeSignature as mt, storeNetworkFeeSignature as vt } from "./storeNetworkFeeSignature-tprCigR1.js";
-import { requiresAutoMintFee as lt } from "./fee-requirements-CCNsxAvJ.js";
-import { DefiProtocol as T, AssetId as v } from "./defi-registry-CD8EUcNu.js";
-import { r as o } from "./index-CfcQ_g3t.js";
-import { toBigInt as J } from "./numbers-CclN2Ohk.js";
-import { VAULTS as R, Vault as f, isVedaVaultChain as X } from "./config-C8BfN_9P.js";
-import { deposit as Et, cancelWithdraw as _t, queueWithdraw as Ct } from "./withdraw-kf8mYbYH.js";
-class gt {
-  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 U({
-      token: t || l.LBTC,
-      chainId: a,
-      env: this.env
-    })).toString();
-  }
-  /**
-   * Sign network fee authorization (EIP-712)
-   */
-  async signNetworkFee(a) {
-    const t = await z({
-      fee: new D(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 at({
-      chainId: a,
-      protocol: t
-    })).toString();
-  }
-  /**
-   * Sign stake and bake authorization
-   */
-  async signStakeAndBake(a) {
-    const t = await it({
-      value: new D(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 rt({
-      account: a.address,
-      chainId: a.chainId,
-      provider: a.provider
-    }) };
-  }
-}
-function pe() {
-  return {
-    id: "evm",
-    chain: "evm",
-    register(r) {
-      return new gt(r.env);
-    }
-  };
-}
-const At = {
-  routes: [
-    // Veda - Ethereum
-    {
-      asset: v.LBTC,
-      sourceChains: [C.ETHEREUM],
-      protocols: [T.Veda],
-      envs: [o.prod]
-    },
-    // Veda - Base
-    {
-      asset: v.LBTC,
-      sourceChains: [C.BASE],
-      protocols: [T.Veda],
-      envs: [o.prod]
-    },
-    // Veda - BSC
-    {
-      asset: v.LBTC,
-      sourceChains: [C.BSC],
-      protocols: [T.Veda],
-      envs: [o.prod]
-    },
-    // Veda - Corn
-    {
-      asset: v.LBTC,
-      sourceChains: [C.CORN],
-      protocols: [T.Veda],
-      envs: [o.prod]
-    },
-    // Silo - Avalanche
-    {
-      asset: v.LBTC,
-      sourceChains: [C.AVALANCHE],
-      protocols: [T.Silo],
-      envs: [o.prod]
-    }
-  ]
-};
-class It 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 n = await this.ctx.getProvider("evm");
-      if (!n)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      const p = (await n.request({
-        method: "eth_accounts"
-      }))[0];
-      if (!p)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      this._account = p, this._chainId = _(this.params.sourceChain);
-      const m = R[f.Veda], h = await q(l.LBTC, this._chainId, this.ctx.env);
-      if (!h)
-        throw c.invalidParameter("token", "Could not get LBTC token info");
-      const E = await O({ chainId: this._chainId }).readContract({
-        address: h.address,
-        abi: h.abi,
-        functionName: "allowance",
-        args: [p, m.vaultContract.address]
-      }), I = new D(s.amount), N = b(I, h.decimals), B = new D(String(E));
-      this._needsApproval = N.isGreaterThan(B), 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 = R[f.Veda], n = await q(l.LBTC, this._chainId, this.ctx.env);
-      if (!n)
-        throw c.invalidParameter("token", "Could not get LBTC token info");
-      const d = new D(this._amount), p = J(b(d, n.decimals)), m = O({ chainId: this._chainId }), h = W({
-        provider: t,
-        chainId: this._chainId
-      }), { request: A } = await m.simulateContract({
-        account: this._account,
-        chain: Z[this._chainId],
-        address: n.address,
-        abi: n.abi,
-        functionName: "approve",
-        args: [s.vaultContract.address, p]
-      }), E = await h.writeContract(A);
-      await M(m, E, "LBTC vault deposit approval"), 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" ? f.Veda : f.Veda;
-      this.emitProgress({
-        status: e.READY,
-        steps: { approval: i.COMPLETE, deploying: i.PENDING }
-      });
-      const n = await Et({
-        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 = n, this.emitProgress({
-        status: e.COMPLETED,
-        steps: { approval: i.COMPLETE, deploying: i.COMPLETE }
-      }), this.emitCompleted(), { txHash: n };
-    }, e.COMPLETED);
-  }
-  get prepareSchema() {
-    return x({
-      amount: L,
-      protocol: pt().min(1, "Protocol is required")
-    });
-  }
-  validateProtocol(t) {
-    if (!At.routes.some(
-      (n) => n.protocols.includes(t) && n.envs.includes(this.ctx.env)
-    ))
-      throw c.invalidParameter(
-        "protocol",
-        `Protocol ${t} is not supported in ${this.ctx.env} environment`
-      );
-  }
-}
-function ft(r, a) {
-  return new It(r, a);
-}
-const Dt = w(v.BTCb, [o.prod]), wt = w(v.BTCb, [o.testnet, o.stage, o.dev, o.ibc]), Pt = w(v.LBTC, [o.prod]), Tt = w(v.LBTC, [
-  o.testnet,
-  o.stage,
-  o.dev,
-  o.ibc
-]), St = {
-  routes: [
-    // Production: BTCb → LBTC
-    {
-      assetsIn: [v.BTCb],
-      assetOut: v.LBTC,
-      sourceChains: Dt,
-      destChains: Pt,
-      envs: [o.prod]
-    },
-    // Testnet
-    {
-      assetsIn: [v.BTCb],
-      assetOut: v.LBTC,
-      sourceChains: wt,
-      destChains: Tt,
-      envs: [o.testnet, o.stage, o.dev, o.ibc]
-    }
-  ],
-  addressSchema: K
-};
-var g = /* @__PURE__ */ ((r) => (r.IDLE = "idle", r.NEEDS_APPROVAL = "needs-approval", r.READY = "ready", r.BRIDGING = "bridging", r.COMPLETED = "completed", r))(g || {});
-class xt 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 = _(this.params.destChain);
-      this.emitProgress({
-        status: g.READY,
-        steps: {
-          approval: i.COMPLETE,
-          execution: i.PENDING,
-          bridging: i.IDLE
-        }
-      });
-      const n = await nt({
-        provider: t,
-        account: this._recipient,
-        data: this._claimData.data,
-        proofSignature: this._claimData.proofSignature,
-        chainId: s,
-        env: this.ctx.env
-      });
-      return this._txHash = n, this.emitProgress({
-        status: g.COMPLETED,
-        steps: {
-          approval: i.COMPLETE,
-          execution: i.COMPLETE,
-          bridging: i.IDLE
-        }
-      }), this.emitCompleted(), { txHash: n };
-    }, g.COMPLETED);
-  }
-  get prepareSchema() {
-    return x({
-      amount: L,
-      recipient: St.addressSchema
-    });
-  }
-}
-function Lt(r, a) {
-  return new xt(r, a);
-}
-const Nt = w(v.BTCb, [o.prod]), Ot = w(v.BTCb, [
-  o.testnet,
-  o.stage,
-  o.dev,
-  o.ibc
-]), Rt = {
-  routes: [
-    // BTC.b → BTC (to Bitcoin Mainnet)
-    {
-      assetIn: v.BTCb,
-      assetOut: v.BTC,
-      sourceChains: Nt,
-      destChain: C.BITCOIN_MAINNET,
-      envs: [o.prod]
-    },
-    // BTC.b → BTC (to Bitcoin Signet - testnet)
-    {
-      assetIn: v.BTCb,
-      assetOut: v.BTC,
-      sourceChains: Ot,
-      destChain: C.BITCOIN_SIGNET,
-      envs: [o.testnet, o.stage, o.dev, o.ibc]
-    }
-    // TODO: Add L-Asset routes when deployed
-    // L-ZEC → ZEC, L-SOL → SOL, L-XRP → XRP, L-DOGE → DOGE
-  ],
-  recipientSchema: Q
-};
-async function k(r, a, t, s) {
-  if (!lt(r))
-    return {
-      requiresAuth: !1,
-      hasValidSignature: !1,
-      feeInSatoshis: null,
-      feeFormatted: null,
-      expirationDate: null
-    };
-  const n = await H(s, r, t), d = await mt({
-    address: a,
-    chainId: r,
-    env: t,
-    tokenAddress: n.address
-  }), p = d.expirationDate ? new Date(Number(d.expirationDate) * 1e3) < /* @__PURE__ */ new Date() : !1, m = d.hasSignature && !p;
-  let h = null, A = null;
-  if (!m) {
-    const E = await U({
-      token: s,
-      chainId: r,
-      env: t
-    });
-    h = BigInt(E.times(1e8).toFixed(0)), A = E.toFixed(8);
-  }
-  return {
-    requiresAuth: !0,
-    hasValidSignature: m,
-    feeInSatoshis: h,
-    feeFormatted: A,
-    expirationDate: d.expirationDate ?? null
-  };
-}
-async function F(r) {
-  const { chainId: a, account: t, feeInSatoshis: s, provider: n, env: d, token: p } = r, m = await H(p, a, d), h = await z({
-    fee: s,
-    account: t,
-    chainId: a,
-    provider: n,
-    env: d,
-    token: p
-  });
-  return await vt({
-    signature: h.signature,
-    typedData: h.typedData,
-    address: t,
-    env: d,
-    tokenAddress: m.address
-  }), h;
-}
-function Y() {
-  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", Y());
-    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 n = _(this.params.sourceChain), d = await this.ctx.getProvider("evm");
-      if (!d)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      const m = (await d.request({
-        method: "eth_accounts"
-      }))[0], h = await k(
-        n,
-        m,
-        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.updateStatus(e.NEEDS_FEE_AUTHORIZATION), this.emitProgress({
-          status: e.NEEDS_FEE_AUTHORIZATION,
-          steps: { burning: i.IDLE, releasing: i.IDLE }
-        });
-        return;
-      }
-      this._needsApproval = !1, this.updateStatus(e.READY), this.emitProgress({
-        status: e.READY,
-        steps: { burning: i.IDLE, releasing: i.IDLE }
-      });
-    });
-  }
-  /**
-   * 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 = _(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 F({
-        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 n = (await t.request({
-        method: "eth_accounts"
-      }))[0];
-      if (!n)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      const d = _(this.params.sourceChain);
-      this.emitProgress({
-        status: e.READY,
-        steps: { burning: i.PENDING, releasing: i.IDLE }
-      });
-      const p = await $({
-        provider: t,
-        account: n,
-        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: Rt.recipientSchema
-    });
-  }
-}
-function bt(r, a) {
-  return new Bt(r, a);
-}
-const yt = [
-  V.avalanche,
-  V.avalancheFuji
-];
-function Mt(r) {
-  return yt.includes(r);
-}
-class Ht extends P {
-  constructor(t, s) {
-    super(e.IDLE);
-    u(this, "_amount");
-    u(this, "_txHash");
-    u(this, "_feeAuth", Y());
-    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 n = await this.ctx.getProvider("evm");
-      if (!n)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      const p = (await n.request({
-        method: "eth_accounts"
-      }))[0];
-      if (!p)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      this._account = p;
-      const m = _(this.params.sourceChain);
-      if (Mt(m)) {
-        const E = await H(
-          l.BTCb,
-          m,
-          this.ctx.env,
-          ut.Adapter
-        );
-        this._spenderAddress = E.address;
-        const I = await ot({
-          token: l.BTCb,
-          owner: p,
-          spender: E.address,
-          chainId: m,
-          env: this.ctx.env
-        }), N = new D(s.amount);
-        if (this._needsApproval = I.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(
-        m,
-        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 = _(this.params.sourceChain), n = await ct({
-        account: this._account,
-        token: l.BTCb,
-        spender: this._spenderAddress,
-        amount: this._amount,
-        chainId: s,
-        provider: t,
-        env: this.ctx.env
-      }), d = O({ chainId: s, env: this.ctx.env });
-      await M(d, n, "BTC.b approval"), 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 = _(this.params.sourceChain);
-      await F({
-        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 = _(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 ht({
-        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(r, a) {
-  return new Ht(r, a);
-}
-const Ft = w(v.LBTC, [o.prod]), Yt = w(v.LBTC, [
-  o.testnet,
-  o.stage,
-  o.dev,
-  o.ibc
-]), Vt = j(
-  [v.LBTC, v.BTCb],
-  [o.prod]
-), qt = j(
-  [v.LBTC, v.BTCb],
-  [o.testnet, o.stage, o.dev, o.ibc]
-), Gt = {
-  routes: [
-    // Production: EVM chains with LBTC → Bitcoin Mainnet
-    {
-      sourceChains: Ft,
-      destChain: C.BITCOIN_MAINNET,
-      envs: [o.prod]
-    },
-    // Testnet: EVM chains with LBTC → Bitcoin Signet
-    {
-      sourceChains: Yt,
-      destChain: C.BITCOIN_SIGNET,
-      envs: [o.testnet, o.stage, o.dev, o.ibc]
-    }
-  ],
-  recipientSchema: Q
-}, Ut = {
-  routes: [
-    // Production: Same-chain routes for chains with both LBTC and BTCb
-    ...Vt.map((r) => ({
-      sourceChains: [r],
-      destChain: r,
-      envs: [o.prod]
-    })),
-    // Testnet: Same-chain routes
-    ...qt.map((r) => ({
-      sourceChains: [r],
-      destChain: r,
-      envs: [o.testnet, o.stage, o.dev, o.ibc]
-    }))
-  ],
-  recipientSchema: K
-};
-class zt extends P {
-  constructor(t, s) {
-    super(e.IDLE);
-    u(this, "_amount");
-    u(this, "_recipient");
-    u(this, "_txHash");
-    u(this, "_feeAuth", Y());
-    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 === v.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 n = _(this.params.sourceChain);
-      if (this.isBtcbOutput) {
-        const d = await this.ctx.getProvider("evm");
-        if (!d)
-          throw c.providerMissing(this.params.sourceChain, "evm");
-        const m = (await d.request({
-          method: "eth_accounts"
-        }))[0], h = await k(
-          n,
-          m,
-          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.updateStatus(e.NEEDS_FEE_AUTHORIZATION), this.emitProgress({
-            status: e.NEEDS_FEE_AUTHORIZATION,
-            steps: { burning: i.IDLE, releasing: i.IDLE }
-          });
-          return;
-        }
-      }
-      this.updateStatus(e.READY), this.emitProgress({
-        status: e.READY,
-        steps: { burning: i.IDLE, releasing: i.IDLE }
-      });
-    });
-  }
-  /**
-   * 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 = _(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 F({
-        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 n = (await t.request({
-        method: "eth_accounts"
-      }))[0];
-      if (!n)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      const d = _(this.params.sourceChain), p = this.params.assetOut === v.BTCb;
-      this.emitProgress({
-        status: e.READY,
-        steps: { burning: i.PENDING, releasing: i.IDLE }
-      });
-      const m = await $({
-        provider: t,
-        account: p ? this._recipient : n,
-        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 = m, this.emitProgress({
-        status: e.COMPLETED,
-        steps: {
-          burning: i.COMPLETE,
-          releasing: p ? i.COMPLETE : i.PENDING
-        }
-      }), this.emitCompleted(), { txHash: m };
-    }, e.COMPLETED);
-  }
-  get prepareSchema() {
-    const t = this.params.assetOut === v.BTC ? Gt : Ut;
-    return x({
-      amount: L,
-      recipient: t.recipientSchema
-    });
-  }
-}
-function $t(r, a) {
-  return new zt(r, a);
-}
-const tt = {
-  routes: [
-    // Veda - Ethereum, Base, BSC, Corn
-    {
-      sourceChains: [C.ETHEREUM, C.BASE, C.BSC, C.CORN],
-      protocols: [T.Veda],
-      envs: [o.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 n = (await t.request({
-        method: "eth_accounts"
-      }))[0];
-      if (!n)
-        throw c.providerMissing(this.params.chain, "evm");
-      if (this._account = n, this._chainId = _(this.params.chain), !X(this._chainId))
-        throw new c(
-          y.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 _t({
-        vaultKey: f.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 (!tt.routes.some(
-      (n) => n.protocols.includes(t) && n.envs.includes(this.ctx.env)
-    ))
-      throw c.invalidParameter(
-        "protocol",
-        `Protocol ${t} is not supported for withdrawals in ${this.ctx.env} environment`
-      );
-  }
-}
-class Zt 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 n = await this.ctx.getProvider("evm");
-      if (!n)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      const p = (await n.request({
-        method: "eth_accounts"
-      }))[0];
-      if (!p)
-        throw c.providerMissing(this.params.sourceChain, "evm");
-      if (this._account = p, this._chainId = _(this.params.sourceChain), !X(this._chainId))
-        throw new c(
-          y.PROTOCOL_NOT_SUPPORTED,
-          `Chain ${this.params.sourceChain} does not support Veda vault withdrawals`,
-          { chain: this.params.sourceChain, protocol: this._protocol }
-        );
-      const m = R[f.Veda], h = O({ chainId: this._chainId }), A = await h.readContract({
-        address: m.lensContract.address,
-        abi: m.lensContract.abi,
-        functionName: "balanceOf",
-        args: [p, m.vaultContract.address]
-      }), E = G(String(A), m.decimals), I = new D(s.amount);
-      if (I.isGreaterThan(E))
-        throw new c(
-          y.INSUFFICIENT_SHARES,
-          `Insufficient vault shares. Requested: ${I.toFixed()}, Available: ${E.toFixed()}`,
-          { requested: I.toFixed(), available: E.toFixed() }
-        );
-      const N = await h.readContract({
-        address: m.vaultContract.address,
-        abi: m.vaultContract.abi,
-        functionName: "allowance",
-        args: [p, m.withdrawQueueContracts[this._chainId].address]
-      }), B = G(String(N), m.decimals);
-      this._needsApproval = I.isGreaterThan(B), 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 = R[f.Veda], n = new D(this._amount), d = J(b(n, s.decimals)), p = O({ chainId: this._chainId }), m = W({
-        provider: t,
-        chainId: this._chainId
-      }), h = this._chainId, { request: A } = await p.simulateContract({
-        account: this._account,
-        chain: Z[this._chainId],
-        address: s.vaultContract.address,
-        abi: s.vaultContract.abi,
-        functionName: "approve",
-        args: [s.withdrawQueueContracts[h].address, d]
-      }), E = await m.writeContract(A);
-      await M(p, E, "vault share approval"), 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 Ct({
-        amount: this._amount,
-        approve: !1,
-        vaultKey: f.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 (!tt.routes.some(
-      (n) => n.protocols.includes(t) && n.envs.includes(this.ctx.env)
-    ))
-      throw c.invalidParameter(
-        "protocol",
-        `Protocol ${t} is not supported for withdrawals in ${this.ctx.env} environment`
-      );
-  }
-}
-function Kt(r, a) {
-  return new Zt(r, a);
-}
-function Qt(r, a) {
-  return new Wt(r, a);
-}
-class jt {
-  constructor(a) {
-    u(this, "ctx");
-    this.ctx = dt(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 $t(this.ctx, a);
-  }
-  /**
-   * Deposit BTCb to get LBTC
-   *
-   * Deposits BTC.b to receive LBTC via the claim flow.
-   *
-   * @example
-   * ```typescript
-   * const deposit = evm.deposit({
-   *   assetIn: AssetId.BTCb,
-   *   assetOut: AssetId.LBTC,
-   *   sourceChain: Chain.ETHEREUM,
-   *   destChain: Chain.ETHEREUM,
-   * });
-   * ```
-   */
-  deposit(a) {
-    return Lt(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 ft(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 Kt(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 Qt(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 bt(this.ctx, a);
-  }
-}
-function de(r) {
-  return new jt(r);
-}
-export {
-  jt as EvmActions,
-  g as EvmDepositStatus,
-  de as evmActions,
-  pe as evmModule
-};
-//# sourceMappingURL=EvmActions-DSKThOAy.js.map