@lombard.finance/sdk 4.7.1 → 5.0.0

package/dist/chunks/EvmActions-CUKBeiUw.js

@@ -0,0 +1,1508 @@
+var dt = Object.defineProperty;
+var pt = (r, a, t) => a in r ? dt(r, a, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[a] = t;
+var p = (r, a, t) => pt(r, typeof a != "symbol" ? a + "" : a, t);
+import D from "bignumber.js";
+import { getMintingFee as at, signNetworkFee as it, getStakeAndBakeFee as mt, signStakeAndBake as lt, signLbtcDestinationAddr as vt, waitForTransactionReceipt as U, depositEarn as Et, claimLBTC as Ct, redeemToken as nt, getTokenAllowance as _t, approveToken as gt, depositToken as At, cancelWithdrawInternal as It, withdrawEarn as ft, queueWithdrawInternal as wt } from "./withdrawEarn-QFaMhs0t.js";
+import { Token as v, makeWalletClient as z, CHAIN_ID_TO_VIEM_CHAIN_MAP as b, AddressKind as Dt, ChainId as et } from "./token-addresses-DVnRPyu4.js";
+import { makePublicClient as x, getTokenInfo as q, toBaseDenomination as y, fromBaseDenomination as B, getErrorMessage as Pt, getTokenContractInfo as W } from "./tokens-Btl3GXbc.js";
+import { Chain as I, BaseAction as S, EvmOperationStatus as s, validatePrepareParams as L, LombardError as h, parseChainIdentifier as A, StepStatus as i, objectType as N, evmAmountSchema as O, stringType as Tt, evmAddressSchema as rt, getEvmAssetChains as P, bitcoinAddressSchema as ot, getEvmChainsWithAllAssets as ct, WithdrawErrorCode as V, createEvmCoreContext as St } from "./statusConstants-C3JHNUTC.js";
+import { getNetworkFeeSignature as xt, storeNetworkFeeSignature as Lt } from "./storeNetworkFeeSignature-CY_Z-Wtn.js";
+import { requiresAutoMintFee as Nt } from "./fee-requirements-CCNsxAvJ.js";
+import { DefiProtocol as T, AssetId as l } from "./defi-registry-DULXbu3D.js";
+import { r as o } from "./index-CfcQ_g3t.js";
+import { erc20Abi as st } from "viem";
+import { toBigInt as Z } from "./numbers-CclN2Ohk.js";
+import { isEarnChain as j, EARN_VAULT as M, isBtceVaultChain as G, BTCE_VAULT as $ } from "./config-wnjPtnjd.js";
+class Ot {
+  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 at({
+      token: t || v.LBTC,
+      chainId: a,
+      env: this.env
+    })).toString();
+  }
+  /**
+   * Sign network fee authorization (EIP-712)
+   */
+  async signNetworkFee(a) {
+    const t = await it({
+      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 ?? v.LBTC
+    });
+    return {
+      signature: t.signature,
+      typedData: t.typedData
+    };
+  }
+  /**
+   * Get stake and bake fee for a vault
+   */
+  async getStakeAndBakeFee(a, t) {
+    return (await mt({
+      chainId: a,
+      protocol: t
+    })).toString();
+  }
+  /**
+   * Sign stake and bake authorization
+   */
+  async signStakeAndBake(a) {
+    const t = await lt({
+      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 vt({
+      account: a.address,
+      chainId: a.chainId,
+      provider: a.provider
+    }) };
+  }
+}
+function Pe() {
+  return {
+    id: "evm",
+    chain: "evm",
+    register(r) {
+      return new Ot(r.env);
+    }
+  };
+}
+const Bt = {
+  routes: [
+    // Veda - Ethereum
+    {
+      asset: l.LBTC,
+      sourceChains: [I.ETHEREUM],
+      protocols: [T.Veda],
+      envs: [o.prod]
+    },
+    // Veda - Base
+    {
+      asset: l.LBTC,
+      sourceChains: [I.BASE],
+      protocols: [T.Veda],
+      envs: [o.prod]
+    },
+    // Veda - BSC
+    {
+      asset: l.LBTC,
+      sourceChains: [I.BSC],
+      protocols: [T.Veda],
+      envs: [o.prod]
+    },
+    // Veda - Corn
+    {
+      asset: l.LBTC,
+      sourceChains: [I.CORN],
+      protocols: [T.Veda],
+      envs: [o.prod]
+    },
+    // Silo - Avalanche
+    {
+      asset: l.LBTC,
+      sourceChains: [I.AVALANCHE],
+      protocols: [T.Silo],
+      envs: [o.prod]
+    }
+  ]
+};
+async function Rt({
+  amount: r,
+  approve: a = !0,
+  token: t = v.LBTC,
+  account: e,
+  chainId: n,
+  provider: m,
+  rpcUrl: u,
+  env: d
+}) {
+  const c = M;
+  if (!j(n))
+    throw new Error(
+      `Unsupported chain id: ${n}. Please switch to one of the supported chains: ${c.chains.join(", ")}`
+    );
+  const E = x({ chainId: n, rpcUrl: u }), _ = z({ provider: m, chainId: n }), C = await q(t, n, d, u);
+  if (!C)
+    throw new Error(`Unknown deposit token: ${t}`);
+  const g = D(r), w = Z(
+    y(g, C.decimals)
+  ), H = await E.readContract({
+    address: C.address,
+    abi: C.abi,
+    functionName: "allowance",
+    args: [e, c.vaultContract.address]
+  }), R = B(
+    String(H),
+    C.decimals
+  ), k = await E.readContract({
+    address: C.address,
+    abi: C.abi,
+    functionName: "balanceOf",
+    args: [e]
+  }), X = B(
+    String(k),
+    C.decimals
+  );
+  if (g.isGreaterThan(X))
+    throw new Error(
+      `The deposit amount exceeds the account's balance. 
+Deposit amount: ${g.toFixed()} 
+Balance: ${X.toFixed()}`
+    );
+  if (g.isGreaterThan(R)) {
+    const tt = `The deposit amount exceeds allowance. 
+Deposit amount: ${g.toFixed()} 
+Allowance: ${R.toFixed()}`;
+    if (!a)
+      throw new Error(tt);
+    console.info(tt);
+    try {
+      console.info(`Trying to approve ${w}`);
+      const { request: F } = await E.simulateContract({
+        account: e,
+        chain: b[n],
+        address: C.address,
+        abi: C.abi,
+        functionName: "approve",
+        args: [c.vaultContract.address, w]
+      }), Y = await _.writeContract(F);
+      console.info(`Approve tx hash: ${Y}`), console.info(`Approved ${w} for ${c.vaultContract.address}`);
+    } catch (F) {
+      const Y = Pt(F);
+      throw new Error(
+        `Could not approve ${w} for ${c.vaultContract.address}. 
+Reason: ${Y}`
+      );
+    }
+  }
+  const { request: ut } = await E.simulateContract({
+    account: e,
+    chain: b[n],
+    address: c.tellerContracts[n].address,
+    abi: c.tellerContracts[n].abi,
+    functionName: "deposit",
+    args: [C.address, w, 0n]
+  });
+  return await _.writeContract(ut);
+}
+class bt extends S {
+  constructor(t, e) {
+    super(s.IDLE);
+    p(this, "_amount");
+    p(this, "_protocol");
+    p(this, "_needsApproval", !1);
+    p(this, "_txHash");
+    p(this, "_account");
+    p(this, "_chainId");
+    this.ctx = t, this.params = e;
+  }
+  get amount() {
+    return this._amount;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  get needsApproval() {
+    return this._needsApproval;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  /**
+   * Returns true when the deposit should go through the BTCe ERC-4626 wrapper:
+   * Veda protocol on a chain that has the BTCe contract deployed.
+   */
+  isVedaBtcePath() {
+    return this._protocol === T.Veda && this._chainId !== void 0 && G(this._chainId);
+  }
+  /**
+   * Returns the ERC-20 spender address for LBTC approval:
+   * - BTCe wrapper address for Veda on BTCe-supported chains
+   * - LBTCv BoringVault address for all other cases
+   */
+  getSpenderAddress() {
+    return this.isVedaBtcePath() ? $.contracts[this._chainId] : M.vaultContract.address;
+  }
+  async prepare(t) {
+    return this.assertStatus(s.IDLE, "prepare"), this.act(async () => {
+      const e = L(this.prepareSchema, t);
+      this._amount = e.amount, this._protocol = t.protocol, this.validateProtocol(t.protocol);
+      const n = await this.ctx.getProvider("evm");
+      if (!n)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const u = (await n.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!u)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      this._account = u, this._chainId = A(this.params.sourceChain);
+      const d = await q(
+        v.LBTC,
+        this._chainId,
+        this.ctx.env
+      );
+      if (!d)
+        throw h.invalidParameter(
+          "token",
+          "Could not get LBTC token info"
+        );
+      const c = this.getSpenderAddress(), _ = await x({ chainId: this._chainId }).readContract({
+        address: d.address,
+        abi: st,
+        functionName: "allowance",
+        args: [u, c]
+      }), C = new D(e.amount), g = y(C, d.decimals), w = new D(String(_));
+      this._needsApproval = g.isGreaterThan(w), this._needsApproval ? (this.emitProgress({
+        status: s.NEEDS_APPROVAL,
+        steps: { approval: i.PENDING, deploying: i.IDLE }
+      }), this.updateStatus(s.NEEDS_APPROVAL)) : (this.emitProgress({
+        status: s.READY,
+        steps: {
+          approval: i.COMPLETE,
+          deploying: i.PENDING
+        }
+      }), this.updateStatus(s.READY));
+    });
+  }
+  async approve() {
+    return this.assertStatus(s.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      if (!this._account || !this._chainId || !this._amount)
+        throw h.missingParameter("account, chainId, or amount");
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const e = await q(
+        v.LBTC,
+        this._chainId,
+        this.ctx.env
+      );
+      if (!e)
+        throw h.invalidParameter(
+          "token",
+          "Could not get LBTC token info"
+        );
+      const n = new D(this._amount), m = Z(
+        y(n, e.decimals)
+      ), u = this.getSpenderAddress(), d = x({ chainId: this._chainId }), c = z({
+        provider: t,
+        chainId: this._chainId
+      }), { request: E } = await d.simulateContract({
+        account: this._account,
+        chain: b[this._chainId],
+        address: e.address,
+        abi: st,
+        functionName: "approve",
+        args: [u, m]
+      }), _ = await c.writeContract(E);
+      await U(
+        d,
+        _,
+        "LBTC deposit approval"
+      ), this._needsApproval = !1, this.emitProgress({
+        status: s.READY,
+        steps: { approval: i.COMPLETE, deploying: i.PENDING }
+      });
+    }, s.READY);
+  }
+  async execute() {
+    return this.assertStatus(s.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      if (!this._account || !this._chainId)
+        throw h.missingParameter("account or chainId");
+      this.emitProgress({
+        status: s.READY,
+        steps: { approval: i.COMPLETE, deploying: i.PENDING }
+      });
+      let e;
+      return this.isVedaBtcePath() ? e = await Et({
+        token: v.LBTC,
+        amount: this._amount,
+        receiver: this.params.recipient,
+        approve: !1,
+        account: this._account,
+        chainId: this._chainId,
+        provider: t,
+        env: this.ctx.env
+      }) : e = await Rt({
+        amount: this._amount,
+        approve: !1,
+        token: v.LBTC,
+        account: this._account,
+        chainId: this._chainId,
+        provider: t,
+        env: this.ctx.env
+      }), this._txHash = e, this.emitProgress({
+        status: s.COMPLETED,
+        steps: {
+          approval: i.COMPLETE,
+          deploying: i.COMPLETE
+        }
+      }), this.emitCompleted(), { txHash: e };
+    }, s.COMPLETED);
+  }
+  get prepareSchema() {
+    return N({
+      amount: O,
+      protocol: Tt().min(1, "Protocol is required")
+    });
+  }
+  validateProtocol(t) {
+    if (!Bt.routes.some(
+      (n) => n.protocols.includes(t) && n.envs.includes(this.ctx.env)
+    ))
+      throw h.invalidParameter(
+        "protocol",
+        `Protocol ${t} is not supported in ${this.ctx.env} environment`
+      );
+  }
+}
+function yt(r, a) {
+  return new bt(r, a);
+}
+const Mt = P(l.BTCb, [o.prod]), Ht = P(l.BTCb, [
+  o.testnet,
+  o.stage,
+  o.dev,
+  o.ibc
+]), kt = P(l.LBTC, [o.prod]), Ft = P(l.LBTC, [
+  o.testnet,
+  o.stage,
+  o.dev,
+  o.ibc
+]), Yt = {
+  routes: [
+    // Production: BTCb → LBTC
+    {
+      assetsIn: [l.BTCb],
+      assetOut: l.LBTC,
+      sourceChains: Mt,
+      destChains: kt,
+      envs: [o.prod]
+    },
+    // Testnet
+    {
+      assetsIn: [l.BTCb],
+      assetOut: l.LBTC,
+      sourceChains: Ht,
+      destChains: Ft,
+      envs: [o.testnet, o.stage, o.dev, o.ibc]
+    }
+  ],
+  addressSchema: rt
+};
+var f = /* @__PURE__ */ ((r) => (r.IDLE = "idle", r.NEEDS_APPROVAL = "needs-approval", r.READY = "ready", r.BRIDGING = "bridging", r.COMPLETED = "completed", r))(f || {});
+class qt extends S {
+  constructor(t, e) {
+    super(f.IDLE);
+    p(this, "_amount");
+    p(this, "_recipient");
+    p(this, "_needsApproval", !1);
+    p(this, "_txHash");
+    p(this, "_claimData");
+    this.ctx = t, this.params = e;
+  }
+  get amount() {
+    return this._amount;
+  }
+  get recipient() {
+    return this._recipient;
+  }
+  get needsApproval() {
+    return this._needsApproval;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  setClaimData(t, e) {
+    this._claimData = { data: t, proofSignature: e };
+  }
+  async prepare(t) {
+    return this.assertStatus(f.IDLE, "prepare"), this.act(async () => {
+      const e = L(this.prepareSchema, t, {
+        destChain: this.params.destChain
+      });
+      this._amount = e.amount, this._recipient = e.recipient, this._needsApproval = !1, this.emitProgress({
+        status: f.READY,
+        steps: {
+          approval: i.COMPLETE,
+          execution: i.IDLE,
+          bridging: i.IDLE
+        }
+      });
+    }, f.READY);
+  }
+  async approve() {
+    return this.assertStatus(f.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      this._needsApproval = !1;
+    }, f.READY);
+  }
+  async execute() {
+    if (this.assertStatus(f.READY, "execute"), !this._claimData)
+      throw h.missingParameter("claimData");
+    return this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const e = A(this.params.destChain);
+      this.emitProgress({
+        status: f.READY,
+        steps: {
+          approval: i.COMPLETE,
+          execution: i.PENDING,
+          bridging: i.IDLE
+        }
+      });
+      const n = await Ct({
+        provider: t,
+        account: this._recipient,
+        data: this._claimData.data,
+        proofSignature: this._claimData.proofSignature,
+        chainId: e,
+        env: this.ctx.env
+      });
+      return this._txHash = n, this.emitProgress({
+        status: f.COMPLETED,
+        steps: {
+          approval: i.COMPLETE,
+          execution: i.COMPLETE,
+          bridging: i.IDLE
+        }
+      }), this.emitCompleted(), { txHash: n };
+    }, f.COMPLETED);
+  }
+  get prepareSchema() {
+    return N({
+      amount: O,
+      recipient: Yt.addressSchema
+    });
+  }
+}
+function Vt(r, a) {
+  return new qt(r, a);
+}
+const Gt = P(l.BTCb, [o.prod]), $t = P(l.BTCb, [
+  o.testnet,
+  o.stage,
+  o.dev,
+  o.ibc
+]), Ut = {
+  routes: [
+    // BTC.b → BTC (to Bitcoin Mainnet)
+    {
+      assetIn: l.BTCb,
+      assetOut: l.BTC,
+      sourceChains: Gt,
+      destChain: I.BITCOIN_MAINNET,
+      envs: [o.prod]
+    },
+    // BTC.b → BTC (to Bitcoin Signet - testnet)
+    {
+      assetIn: l.BTCb,
+      assetOut: l.BTC,
+      sourceChains: $t,
+      destChain: I.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: ot
+};
+async function K(r, a, t, e) {
+  if (!Nt(r))
+    return {
+      requiresAuth: !1,
+      hasValidSignature: !1,
+      feeInSatoshis: null,
+      feeFormatted: null,
+      expirationDate: null
+    };
+  const n = await W(e, r, t), m = await xt({
+    address: a,
+    chainId: r,
+    env: t,
+    tokenAddress: n.address
+  }), u = m.expirationDate ? new Date(Number(m.expirationDate) * 1e3) < /* @__PURE__ */ new Date() : !1, d = m.hasSignature && !u;
+  let c = null, E = null;
+  if (!d) {
+    const _ = await at({
+      token: e,
+      chainId: r,
+      env: t
+    });
+    c = BigInt(_.times(1e8).toFixed(0)), E = _.toFixed(8);
+  }
+  return {
+    requiresAuth: !0,
+    hasValidSignature: d,
+    feeInSatoshis: c,
+    feeFormatted: E,
+    expirationDate: m.expirationDate ?? null
+  };
+}
+async function Q(r) {
+  const { chainId: a, account: t, feeInSatoshis: e, provider: n, env: m, token: u } = r, d = await W(u, a, m), c = await it({
+    fee: e,
+    account: t,
+    chainId: a,
+    provider: n,
+    env: m,
+    token: u
+  });
+  return await Lt({
+    signature: c.signature,
+    typedData: c.typedData,
+    address: t,
+    env: m,
+    tokenAddress: d.address
+  }), c;
+}
+function J() {
+  return {
+    requiresAuth: !1,
+    isAuthorized: !1,
+    feeInSatoshis: null,
+    feeFormatted: null,
+    expirationDate: null
+  };
+}
+class zt extends S {
+  constructor(t, e) {
+    super(s.IDLE);
+    p(this, "_amount");
+    p(this, "_recipient");
+    p(this, "_needsApproval", !1);
+    p(this, "_txHash");
+    p(this, "_feeAuth", J());
+    this.ctx = t, this.params = e;
+  }
+  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(s.IDLE, "prepare"), this.act(async () => {
+      const e = L(this.prepareSchema, t, {
+        destChain: this.params.destChain
+      });
+      this._amount = e.amount, this._recipient = e.recipient;
+      const n = A(this.params.sourceChain), m = await this.ctx.getProvider("evm");
+      if (!m)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const d = (await m.request({
+        method: "eth_accounts"
+      }))[0], c = await K(
+        n,
+        d,
+        this.ctx.env,
+        v.BTCb
+      );
+      if (this._feeAuth = {
+        requiresAuth: c.requiresAuth,
+        isAuthorized: c.hasValidSignature,
+        feeInSatoshis: c.feeInSatoshis,
+        feeFormatted: c.feeFormatted,
+        expirationDate: c.expirationDate
+      }, c.requiresAuth && !c.hasValidSignature) {
+        this.updateStatus(s.NEEDS_FEE_AUTHORIZATION), this.emitProgress({
+          status: s.NEEDS_FEE_AUTHORIZATION,
+          steps: { burning: i.IDLE, releasing: i.IDLE }
+        });
+        return;
+      }
+      this._needsApproval = !1, this.updateStatus(s.READY), this.emitProgress({
+        status: s.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(
+      s.NEEDS_FEE_AUTHORIZATION,
+      "authorizeFee"
+    ), !this._feeAuth.feeInSatoshis)
+      throw h.missingParameter("feeInSatoshis");
+    return this.act(async () => {
+      const t = A(this.params.sourceChain), e = await this.ctx.getProvider("evm");
+      if (!e)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const m = (await e.request({
+        method: "eth_accounts"
+      }))[0];
+      await Q({
+        chainId: t,
+        account: m,
+        feeInSatoshis: this._feeAuth.feeInSatoshis,
+        provider: e,
+        env: this.ctx.env,
+        token: v.BTCb
+      }), this._feeAuth.isAuthorized = !0, this.emitProgress({
+        status: s.READY,
+        steps: { burning: i.IDLE, releasing: i.IDLE }
+      });
+    }, s.READY);
+  }
+  async approve() {
+    return this.assertStatus(s.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      this._needsApproval = !1, this.emitProgress({
+        status: s.READY,
+        steps: { burning: i.IDLE, releasing: i.IDLE }
+      });
+    }, s.READY);
+  }
+  async execute() {
+    return this.assertStatus(s.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const n = (await t.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!n)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const m = A(this.params.sourceChain);
+      this.emitProgress({
+        status: s.READY,
+        steps: { burning: i.PENDING, releasing: i.IDLE }
+      });
+      const u = await nt({
+        provider: t,
+        account: n,
+        amount: this._amount,
+        btcAddress: this._recipient,
+        // Bitcoin address to receive BTC
+        chainId: m,
+        env: this.ctx.env,
+        tokenIn: v.BTCb,
+        tokenOut: void 0
+        // Native BTC output
+      });
+      return this._txHash = u, this.emitProgress({
+        status: s.COMPLETED,
+        steps: { burning: i.COMPLETE, releasing: i.PENDING }
+      }), this.emitCompleted(), { txHash: u };
+    }, s.COMPLETED);
+  }
+  get prepareSchema() {
+    return N({
+      amount: O,
+      recipient: Ut.recipientSchema
+    });
+  }
+}
+function Wt(r, a) {
+  return new zt(r, a);
+}
+const Zt = [
+  et.avalanche,
+  et.avalancheFuji
+];
+function jt(r) {
+  return Zt.includes(r);
+}
+class Kt extends S {
+  constructor(t, e) {
+    super(s.IDLE);
+    p(this, "_amount");
+    p(this, "_txHash");
+    p(this, "_feeAuth", J());
+    p(this, "_account");
+    p(this, "_needsApproval", !1);
+    p(this, "_spenderAddress");
+    this.ctx = t, this.params = e;
+  }
+  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(s.IDLE, "prepare"), this.act(async () => {
+      const e = L(this.prepareSchema, t);
+      this._amount = e.amount;
+      const n = await this.ctx.getProvider("evm");
+      if (!n)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const u = (await n.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!u)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      this._account = u;
+      const d = A(this.params.sourceChain);
+      if (jt(d)) {
+        const _ = await W(
+          v.BTCb,
+          d,
+          this.ctx.env,
+          Dt.Adapter
+        );
+        this._spenderAddress = _.address;
+        const C = await _t({
+          token: v.BTCb,
+          owner: u,
+          spender: _.address,
+          chainId: d,
+          env: this.ctx.env
+        }), g = new D(e.amount);
+        if (this._needsApproval = C.isLessThan(g), this._needsApproval) {
+          this.emitProgress({
+            status: s.NEEDS_APPROVAL,
+            steps: { approval: i.PENDING, staking: i.IDLE }
+          }), this.updateStatus(s.NEEDS_APPROVAL);
+          return;
+        }
+      }
+      const c = await K(
+        d,
+        u,
+        this.ctx.env,
+        v.LBTC
+      );
+      this._feeAuth = {
+        requiresAuth: c.requiresAuth,
+        isAuthorized: c.hasValidSignature,
+        feeInSatoshis: c.feeInSatoshis,
+        feeFormatted: c.feeFormatted,
+        expirationDate: c.expirationDate
+      }, c.requiresAuth && !c.hasValidSignature ? (this.emitProgress({
+        status: s.NEEDS_FEE_AUTHORIZATION,
+        steps: { staking: i.IDLE }
+      }), this.updateStatus(s.NEEDS_FEE_AUTHORIZATION)) : (this.emitProgress({
+        status: s.READY,
+        steps: { staking: i.PENDING }
+      }), this.updateStatus(s.READY));
+    });
+  }
+  /**
+   * Approve BTC.b spending (Avalanche only)
+   *
+   * Must be called when status is NEEDS_APPROVAL.
+   */
+  async approve() {
+    return this.assertStatus(s.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      if (!this._account || !this._spenderAddress || !this._amount)
+        throw h.missingParameter(
+          "account, spenderAddress, or amount"
+        );
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const e = A(this.params.sourceChain), n = await gt({
+        account: this._account,
+        token: v.BTCb,
+        spender: this._spenderAddress,
+        amount: this._amount,
+        chainId: e,
+        provider: t,
+        env: this.ctx.env
+      }), m = x({ chainId: e, env: this.ctx.env });
+      await U(m, n, "BTC.b approval"), this._needsApproval = !1, this.emitProgress({
+        status: s.READY,
+        steps: { approval: i.COMPLETE, staking: i.PENDING }
+      });
+    }, s.READY);
+  }
+  async authorizeFee() {
+    return this.assertStatus(
+      s.NEEDS_FEE_AUTHORIZATION,
+      "authorizeFee"
+    ), this.act(async () => {
+      if (!this._feeAuth.feeInSatoshis)
+        throw h.missingParameter("feeInSatoshis");
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const e = A(this.params.sourceChain);
+      await Q({
+        chainId: e,
+        account: this._account,
+        feeInSatoshis: this._feeAuth.feeInSatoshis,
+        provider: t,
+        env: this.ctx.env,
+        token: v.LBTC
+        // BTC.b → LBTC uses LBTC token for fee signature
+      }), this._feeAuth = {
+        ...this._feeAuth,
+        isAuthorized: !0
+      }, this.emitProgress({
+        status: s.READY,
+        steps: { staking: i.PENDING }
+      });
+    }, s.READY);
+  }
+  async execute() {
+    return this.assertStatus(s.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const e = A(this.params.sourceChain), m = (await t.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!m)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      this.emitProgress({
+        status: s.READY,
+        steps: { staking: i.PENDING }
+      });
+      const u = await At({
+        amount: this._amount,
+        tokenIn: v.BTCb,
+        tokenOut: v.LBTC,
+        account: m,
+        chainId: e,
+        provider: t,
+        env: this.ctx.env
+      });
+      return this._txHash = u, this.emitProgress({
+        status: s.COMPLETED,
+        steps: { staking: i.COMPLETE }
+      }), this.emitCompleted(), { txHash: u };
+    }, s.COMPLETED);
+  }
+  get prepareSchema() {
+    return N({
+      amount: O
+    });
+  }
+}
+function Qt(r, a) {
+  return new Kt(r, a);
+}
+const Jt = P(l.LBTC, [o.prod]), Xt = P(l.LBTC, [
+  o.testnet,
+  o.stage,
+  o.dev,
+  o.ibc
+]), te = ct(
+  [l.LBTC, l.BTCb],
+  [o.prod]
+), ee = ct(
+  [l.LBTC, l.BTCb],
+  [o.testnet, o.stage, o.dev, o.ibc]
+), se = {
+  routes: [
+    // Production: EVM chains with LBTC → Bitcoin Mainnet
+    {
+      sourceChains: Jt,
+      destChain: I.BITCOIN_MAINNET,
+      envs: [o.prod]
+    },
+    // Testnet: EVM chains with LBTC → Bitcoin Signet
+    {
+      sourceChains: Xt,
+      destChain: I.BITCOIN_SIGNET,
+      envs: [o.testnet, o.stage, o.dev, o.ibc]
+    }
+  ],
+  recipientSchema: ot
+}, ae = {
+  routes: [
+    // Production: Same-chain routes for chains with both LBTC and BTCb
+    ...te.map((r) => ({
+      sourceChains: [r],
+      destChain: r,
+      envs: [o.prod]
+    })),
+    // Testnet: Same-chain routes
+    ...ee.map((r) => ({
+      sourceChains: [r],
+      destChain: r,
+      envs: [o.testnet, o.stage, o.dev, o.ibc]
+    }))
+  ],
+  recipientSchema: rt
+};
+class ie extends S {
+  constructor(t, e) {
+    super(s.IDLE);
+    p(this, "_amount");
+    p(this, "_recipient");
+    p(this, "_txHash");
+    p(this, "_feeAuth", J());
+    this.ctx = t, this.params = e;
+  }
+  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 === l.BTCb;
+  }
+  async prepare(t) {
+    return this.assertStatus(s.IDLE, "prepare"), this.act(async () => {
+      const e = L(this.prepareSchema, t, {
+        destChain: this.params.destChain
+      });
+      this._amount = e.amount, this._recipient = e.recipient;
+      const n = A(this.params.sourceChain);
+      if (this.isBtcbOutput) {
+        const m = await this.ctx.getProvider("evm");
+        if (!m)
+          throw h.providerMissing(this.params.sourceChain, "evm");
+        const d = (await m.request({
+          method: "eth_accounts"
+        }))[0], c = await K(
+          n,
+          d,
+          this.ctx.env,
+          v.BTCb
+        );
+        if (this._feeAuth = {
+          requiresAuth: c.requiresAuth,
+          isAuthorized: c.hasValidSignature,
+          feeInSatoshis: c.feeInSatoshis,
+          feeFormatted: c.feeFormatted,
+          expirationDate: c.expirationDate
+        }, c.requiresAuth && !c.hasValidSignature) {
+          this.updateStatus(s.NEEDS_FEE_AUTHORIZATION), this.emitProgress({
+            status: s.NEEDS_FEE_AUTHORIZATION,
+            steps: { burning: i.IDLE, releasing: i.IDLE }
+          });
+          return;
+        }
+      }
+      this.updateStatus(s.READY), this.emitProgress({
+        status: s.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(
+      s.NEEDS_FEE_AUTHORIZATION,
+      "authorizeFee"
+    ), !this._feeAuth.feeInSatoshis)
+      throw h.missingParameter("feeInSatoshis");
+    return this.act(async () => {
+      const t = A(this.params.sourceChain), e = await this.ctx.getProvider("evm");
+      if (!e)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const m = (await e.request({
+        method: "eth_accounts"
+      }))[0];
+      await Q({
+        chainId: t,
+        account: m,
+        feeInSatoshis: this._feeAuth.feeInSatoshis,
+        provider: e,
+        env: this.ctx.env,
+        token: v.BTCb
+      }), this._feeAuth.isAuthorized = !0, this.emitProgress({
+        status: s.READY,
+        steps: { burning: i.IDLE, releasing: i.IDLE }
+      });
+    }, s.READY);
+  }
+  async execute() {
+    return this.assertStatus(s.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const n = (await t.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!n)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const m = A(this.params.sourceChain), u = this.params.assetOut === l.BTCb;
+      this.emitProgress({
+        status: s.READY,
+        steps: { burning: i.PENDING, releasing: i.IDLE }
+      });
+      const d = await nt({
+        provider: t,
+        account: u ? this._recipient : n,
+        amount: this._amount,
+        btcAddress: u ? void 0 : this._recipient,
+        chainId: m,
+        env: this.ctx.env,
+        tokenIn: v.LBTC,
+        tokenOut: u ? v.BTCb : void 0
+      });
+      return this._txHash = d, this.emitProgress({
+        status: s.COMPLETED,
+        steps: {
+          burning: i.COMPLETE,
+          releasing: u ? i.COMPLETE : i.PENDING
+        }
+      }), this.emitCompleted(), { txHash: d };
+    }, s.COMPLETED);
+  }
+  get prepareSchema() {
+    const t = this.params.assetOut === l.BTC ? se : ae;
+    return N({
+      amount: O,
+      recipient: t.recipientSchema
+    });
+  }
+}
+function ne(r, a) {
+  return new ie(r, a);
+}
+const ht = {
+  routes: [
+    // Veda - Ethereum, Base, BSC, Corn
+    {
+      sourceChains: [I.ETHEREUM, I.BASE, I.BSC, I.CORN],
+      protocols: [T.Veda],
+      envs: [o.prod]
+    }
+  ]
+};
+class re extends S {
+  constructor(t, e) {
+    super(s.IDLE);
+    p(this, "_txHash");
+    p(this, "_account");
+    p(this, "_chainId");
+    this.ctx = t, this.params = e;
+  }
+  get txHash() {
+    return this._txHash;
+  }
+  async prepare() {
+    return this.assertStatus(s.IDLE, "prepare"), this.act(async () => {
+      this.validateProtocol(this.params.protocol);
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.chain, "evm");
+      const n = (await t.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!n)
+        throw h.providerMissing(this.params.chain, "evm");
+      if (this._account = n, this._chainId = A(this.params.chain), !j(this._chainId))
+        throw new h(
+          V.PROTOCOL_NOT_SUPPORTED,
+          `Chain ${this.params.chain} does not support Veda vault withdrawals`,
+          { chain: this.params.chain, protocol: this.params.protocol }
+        );
+      this.emitProgress({
+        status: s.READY,
+        steps: { cancelling: i.PENDING }
+      }), this.updateStatus(s.READY);
+    });
+  }
+  async execute() {
+    return this.assertStatus(s.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.chain, "evm");
+      if (!this._account || !this._chainId)
+        throw h.missingParameter("account or chainId");
+      this.emitProgress({
+        status: s.READY,
+        steps: { cancelling: i.PENDING }
+      });
+      const e = await It({
+        account: this._account,
+        chainId: this._chainId,
+        provider: t,
+        env: this.ctx.env
+      });
+      return this._txHash = e, this.emitProgress({
+        status: s.COMPLETED,
+        steps: { cancelling: i.COMPLETE }
+      }), this.emitCompleted(), { txHash: e };
+    }, s.COMPLETED);
+  }
+  validateProtocol(t) {
+    if (!ht.routes.some(
+      (n) => n.protocols.includes(t) && n.envs.includes(this.ctx.env)
+    ))
+      throw h.invalidParameter(
+        "protocol",
+        `Protocol ${t} is not supported for withdrawals in ${this.ctx.env} environment`
+      );
+  }
+}
+class oe extends S {
+  constructor(t, e) {
+    super(s.IDLE);
+    p(this, "_amount");
+    p(this, "_protocol");
+    p(this, "_needsApproval", !1);
+    p(this, "_txHash");
+    p(this, "_account");
+    p(this, "_chainId");
+    this.ctx = t, this.params = e;
+  }
+  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(s.IDLE, "prepare"), this.act(async () => {
+      const e = L(this.prepareSchema, t);
+      this._amount = e.amount, this._protocol = this.params.protocol, this.validateProtocol(this.params.protocol);
+      const n = await this.ctx.getProvider("evm");
+      if (!n)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const u = (await n.request({
+        method: "eth_accounts"
+      }))[0];
+      if (!u)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      if (this._account = u, this._chainId = A(this.params.sourceChain), !j(this._chainId))
+        throw new h(
+          V.PROTOCOL_NOT_SUPPORTED,
+          `Chain ${this.params.sourceChain} does not support Veda vault withdrawals`,
+          { chain: this.params.sourceChain, protocol: this._protocol }
+        );
+      const d = M, c = x({ chainId: this._chainId }), E = new D(e.amount), _ = await c.readContract({
+        address: d.lensContract.address,
+        abi: d.lensContract.abi,
+        functionName: "balanceOf",
+        args: [u, d.vaultContract.address]
+      }), C = B(
+        String(_),
+        d.decimals
+      );
+      let g = C;
+      if (G(this._chainId)) {
+        const R = await c.readContract({
+          address: $.contracts[this._chainId],
+          abi: $.abi,
+          functionName: "balanceOf",
+          args: [u]
+        }), k = B(
+          String(R),
+          d.decimals
+        );
+        g = C.plus(k);
+      }
+      if (E.isGreaterThan(g))
+        throw new h(
+          V.INSUFFICIENT_SHARES,
+          `Insufficient vault shares. Requested: ${E.toFixed()}, Available: ${g.toFixed()}`,
+          { requested: E.toFixed(), available: g.toFixed() }
+        );
+      const w = await c.readContract({
+        address: d.vaultContract.address,
+        abi: d.vaultContract.abi,
+        functionName: "allowance",
+        args: [u, d.withdrawQueueContracts[this._chainId].address]
+      }), H = B(
+        String(w),
+        d.decimals
+      );
+      this._needsApproval = E.isGreaterThan(H), this._needsApproval ? (this.emitProgress({
+        status: s.NEEDS_APPROVAL,
+        steps: { approval: i.PENDING, queueing: i.IDLE }
+      }), this.updateStatus(s.NEEDS_APPROVAL)) : (this.emitProgress({
+        status: s.READY,
+        steps: {
+          approval: i.COMPLETE,
+          queueing: i.PENDING
+        }
+      }), this.updateStatus(s.READY));
+    });
+  }
+  async approve() {
+    return this.assertStatus(s.NEEDS_APPROVAL, "approve"), this.act(async () => {
+      if (!this._account || !this._chainId || !this._amount)
+        throw h.missingParameter("account, chainId, or amount");
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      const e = M, n = new D(this._amount), m = Z(y(n, e.decimals)), u = x({ chainId: this._chainId }), d = z({
+        provider: t,
+        chainId: this._chainId
+      }), c = this._chainId, { request: E } = await u.simulateContract({
+        account: this._account,
+        chain: b[this._chainId],
+        address: e.vaultContract.address,
+        abi: e.vaultContract.abi,
+        functionName: "approve",
+        args: [e.withdrawQueueContracts[c].address, m]
+      }), _ = await d.writeContract(E);
+      await U(
+        u,
+        _,
+        "vault share approval"
+      ), this._needsApproval = !1, this.emitProgress({
+        status: s.READY,
+        steps: { approval: i.COMPLETE, queueing: i.PENDING }
+      });
+    }, s.READY);
+  }
+  async execute() {
+    return this.assertStatus(s.READY, "execute"), this.act(async () => {
+      const t = await this.ctx.getProvider("evm");
+      if (!t)
+        throw h.providerMissing(this.params.sourceChain, "evm");
+      if (!this._account || !this._chainId || !this._amount)
+        throw h.missingParameter("account, chainId, or amount");
+      this.emitProgress({
+        status: s.READY,
+        steps: { approval: i.COMPLETE, queueing: i.PENDING }
+      });
+      let e;
+      return G(this._chainId) ? e = (await ft({
+        amount: this._amount,
+        account: this._account,
+        chainId: this._chainId,
+        provider: t,
+        env: this.ctx.env
+      })).queueTxHash : e = await wt({
+        amount: this._amount,
+        approve: !1,
+        account: this._account,
+        chainId: this._chainId,
+        provider: t,
+        env: this.ctx.env
+      }), this._txHash = e, this.emitProgress({
+        status: s.COMPLETED,
+        steps: { approval: i.COMPLETE, queueing: i.COMPLETE }
+      }), this.emitCompleted(), { txHash: e };
+    }, s.COMPLETED);
+  }
+  get prepareSchema() {
+    return N({
+      amount: O
+    });
+  }
+  validateProtocol(t) {
+    if (!ht.routes.some(
+      (n) => n.protocols.includes(t) && n.envs.includes(this.ctx.env)
+    ))
+      throw h.invalidParameter(
+        "protocol",
+        `Protocol ${t} is not supported for withdrawals in ${this.ctx.env} environment`
+      );
+  }
+}
+function ce(r, a) {
+  return new oe(r, a);
+}
+function he(r, a) {
+  return new re(r, a);
+}
+class ue {
+  constructor(a) {
+    p(this, "ctx");
+    this.ctx = St(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 Qt(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 ne(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 Vt(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 yt(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 ce(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 he(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 Wt(this.ctx, a);
+  }
+}
+function Te(r) {
+  return new ue(r);
+}
+export {
+  ue as EvmActions,
+  f as EvmDepositStatus,
+  Te as evmActions,
+  Pe as evmModule
+};
+//# sourceMappingURL=EvmActions-CUKBeiUw.js.map