@lombard.finance/sdk 4.1.0 → 4.2.0

package/dist/chunks/BtcActions-DGqmtxjd.js

@@ -0,0 +1,1791 @@
+var V = Object.defineProperty;
+var U = (e, i, s) => i in e ? V(e, i, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[i] = s;
+var D = (e, i, s) => U(e, typeof i != "symbol" ? i + "" : i, s);
+import G from "axios";
+import { T as S, a as K, q as b } from "./token-addresses-DmAr89jP.js";
+import { q as o, L as u, V as c, y as j, C as g, A as Z, a3 as W, a4 as X, z as J, _ as N, g as y, n as Q, B as a, X as v, e as tt, a5 as et, a6 as R, a7 as st, a8 as it, a9 as rt, aa as nt, ab as at } from "./statusConstants-ZJia15m2.js";
+import { r as h } from "./index-CfcQ_g3t.js";
+import { g as _ } from "./tokens-Bw35TZqd.js";
+import { t as T } from "./satoshi-Ch6y8aYG.js";
+import { A as f, b as I } from "./defi-registry-dhrQMy94.js";
+import { S as ot, a as ut } from "./getUserStakeAndBakeSignature-2xPkL9v_.js";
+import { V as dt } from "./config-_8X_2sG4.js";
+import { pad as ht } from "viem";
+const ct = "ERR_NETWORK", pt = "This may be due to your Adblocker. Please disable any Adblocker and refresh the page to restore full functionality.";
+function gt(e) {
+  const { code: i, message: s } = e;
+  throw i === ct ? new Error(pt) : new Error(s);
+}
+const At = {
+  mempoolApiUrl: "https://mempool.space/signet"
+}, Dt = {
+  mempoolApiUrl: "https://mempool.space"
+}, ft = (e) => e === "mainnet" ? Dt : At;
+async function St(e) {
+  const { mempoolApiUrl: i } = ft(e), s = Math.floor(Date.now() / 1e3), t = `${i}/api/v1/mining/blocks/timestamp/${s}`;
+  try {
+    const { data: n } = await G.get(t);
+    return n.height;
+  } catch (n) {
+    gt(n);
+  }
+}
+class lt {
+  /**
+   * Get current block height from mempool
+   */
+  async getCurrentBlockHeight(i) {
+    return St(i);
+  }
+}
+function Se() {
+  return {
+    id: "btc",
+    chain: "btc",
+    register() {
+      return new lt();
+    }
+  };
+}
+async function B(e) {
+  const {
+    fetchDeposit: i,
+    network: s,
+    btcService: t,
+    requiredConfirmations: n = 6,
+    onProgress: r,
+    onComplete: d
+  } = e, A = await i();
+  if (!A)
+    return;
+  const p = A.blockHeight;
+  if (typeof p != "number")
+    return;
+  const q = await t.getCurrentBlockHeight(s), F = Math.max(0, q - p), x = F >= n, k = A.isClaimed ?? !1, M = {
+    confirmations: F,
+    requiredConfirmations: n,
+    hasEnoughConfirmations: x,
+    isClaimed: k,
+    steps: {
+      created: o.COMPLETE,
+      verifying: x ? o.COMPLETE : o.PENDING,
+      issuing: k ? o.COMPLETE : o.PENDING
+    }
+  };
+  return r == null || r(M), k && (d == null || d()), M;
+}
+function O(e) {
+  if (e === ot)
+    throw new u(
+      c.INVALID_PARAMETER,
+      "Destination address is under sanctions"
+    );
+}
+class P extends j {
+  constructor(s, t, n) {
+    super(n);
+    // ─────────────────────────────────────────────────────────────────────────
+    // Common State
+    // ─────────────────────────────────────────────────────────────────────────
+    D(this, "_amount");
+    D(this, "_recipient");
+    D(this, "_depositAddress");
+    D(this, "_referralCode");
+    D(this, "_chainId");
+    this.ctx = s, this.params = t;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Common Getters
+  // ─────────────────────────────────────────────────────────────────────────
+  /** Amount of BTC to stake/deposit */
+  get amount() {
+    return this._amount;
+  }
+  /** Recipient address on destination chain */
+  get recipient() {
+    return this._recipient;
+  }
+  /** Generated Bitcoin deposit address */
+  get depositAddress() {
+    return this._depositAddress;
+  }
+  /** Referral code (optional) */
+  get referralCode() {
+    return this._referralCode;
+  }
+  /** Bitcoin network mode for monitoring */
+  get bitcoinNetwork() {
+    return this.params.sourceChain === g.BITCOIN_MAINNET ? "mainnet" : "testnet";
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Common Validation
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Get the prepare schema (amount + recipient + referralCode)
+   * Uses abstract getAddressSchema() for chain-specific validation
+   */
+  get prepareSchema() {
+    return Z({
+      amount: X,
+      recipient: this.getAddressSchema(),
+      referralCode: W
+    });
+  }
+  /**
+   * Validate prepare params using Zod
+   * Subclasses can override if they need custom validation
+   */
+  validatePrepareParams(s) {
+    return J(this.prepareSchema, s, {
+      destChain: this.params.destChain
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Ensure Methods (throw if missing)
+  // ─────────────────────────────────────────────────────────────────────────
+  ensureRecipient() {
+    if (!this._recipient)
+      throw u.missingParameter("recipient");
+    return this._recipient;
+  }
+  ensureAmount() {
+    if (!this._amount)
+      throw u.missingParameter("amount");
+    return this._amount;
+  }
+  ensureDepositAddress() {
+    if (!this._depositAddress)
+      throw new u(
+        c.INVALID_PARAMETER,
+        "Deposit address not generated. Call generateDepositAddress() first."
+      );
+    return this._depositAddress;
+  }
+  /**
+   * Get error message for missing authorization
+   * Subclasses can override to provide specific messages
+   */
+  getAuthRequiredMessage() {
+    return "Authorization required. Complete the authorization step first.";
+  }
+  ensureAuthorized() {
+    if (!this.isAuthorized())
+      throw new u(
+        c.INVALID_PARAMETER,
+        this.getAuthRequiredMessage()
+      );
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Common Resume Logic
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Try to resume from an existing deposit address
+   *
+   * This method only stores the deposit address if found.
+   * It does NOT update the status - the caller must do that
+   * after performing any additional validation (e.g., fee authorization).
+   *
+   * @param recipient - The recipient address to check
+   * @returns true if a deposit address was found, false otherwise
+   */
+  async resumeFromExistingDeposit(s) {
+    try {
+      const t = await this.ctx.api.getDepositAddress({
+        address: s,
+        chainId: this.getChainId(),
+        token: this.getExpectedToken(),
+        partnerId: this.ctx.partner.getPartnerId()
+      });
+      return t ? (this._depositAddress = t, !0) : !1;
+    } catch {
+      return !1;
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Common Generate Deposit Address
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Generate a Bitcoin deposit address
+   *
+   * Template method that:
+   * 1. Validates status and authorization
+   * 2. Calls API to generate address
+   * 3. Updates state and emits progress
+   *
+   * Subclasses must implement getDepositAddressParams() to provide API params.
+   */
+  async generateDepositAddressImpl() {
+    const s = this.getStatusConfig();
+    return this.assertStatus(s.ready, "generateDepositAddress"), this.ensureAuthorized(), this._depositAddress ? this._depositAddress : this.act(async () => {
+      const t = this.getDepositAddressParams(), n = await this.ctx.api.generateDepositAddress(t);
+      O(n), this._depositAddress = n;
+      const r = this.getInitialSteps(), d = Object.fromEntries(
+        Object.entries(r).map(([A], p) => [
+          A,
+          p === 0 ? o.COMPLETE : o.IDLE
+        ])
+      );
+      return this.emitProgress({
+        status: s.addressReady,
+        steps: d,
+        metadata: { depositAddress: n }
+      }), n;
+    }, s.addressReady);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Common Execute Pattern
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Execute the action - generate address and optionally send BTC
+   *
+   * Template method that:
+   * 1. Ensures deposit address exists
+   * 2. Tries to send BTC if provider available
+   * 3. Returns result
+   */
+  async executeImpl() {
+    const s = this.getStatusConfig();
+    return this.act(async () => {
+      this.assertStatus(s.addressReady, "execute"), this._depositAddress || await this.generateDepositAddressImpl();
+      const t = this.ensureDepositAddress(), n = await this.trySendBitcoin(t);
+      return n ? { depositAddress: t, txHash: n } : { depositAddress: t };
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Common Progress Emission
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Emit initial progress with action-specific steps
+   */
+  emitInitialProgress() {
+    this.emitProgress({
+      status: this.status,
+      steps: this.getInitialSteps()
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Deposit Monitoring
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Monitor Bitcoin deposit progress
+   */
+  async monitorDeposit() {
+    const s = this._depositAddress, t = this._recipient;
+    if (!s || !t)
+      throw u.missingParameter("depositAddress or recipient");
+    return await B({
+      network: this.bitcoinNetwork,
+      btcService: this.ctx.btc,
+      fetchDeposit: async () => {
+        const d = (await this.ctx.api.getDeposits(t)).find(
+          (A) => A.depositAddress === s
+        );
+        if (d)
+          return {
+            blockHeight: d.blockHeight,
+            isClaimed: d.isClaimed
+          };
+      },
+      onProgress: (r) => {
+        this.emitProgress({
+          status: this.status,
+          steps: r.steps,
+          confirmations: r.confirmations,
+          requiredConfirmations: r.requiredConfirmations,
+          metadata: { isClaimed: r.isClaimed }
+        });
+      },
+      onComplete: () => {
+        this.emitCompleted();
+      }
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Bitcoin Send (Optional)
+  // ─────────────────────────────────────────────────────────────────────────
+  async trySendBitcoin(s) {
+    const t = this._amount;
+    if (t)
+      try {
+        const n = await this.ctx.getProvider("bitcoin");
+        if (!n) return;
+        const r = n;
+        if (r.sendBitcoin) {
+          const d = T(t).toNumber();
+          return r.sendBitcoin(s, d);
+        }
+      } catch {
+      }
+  }
+}
+function w(e, i = S.LBTC) {
+  switch (e) {
+    case f.LBTC:
+      return S.LBTC;
+    case f.BTCb:
+      return S.BTCb;
+    default:
+      return i;
+  }
+}
+async function Ct(e, i) {
+  try {
+    await e.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: `0x${i.toString(16)}` }]
+    });
+  } catch (s) {
+    const t = s;
+    if (t.code === 4902)
+      try {
+        await K({ provider: e, chainId: i }), await e.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: `0x${i.toString(16)}` }]
+        });
+        return;
+      } catch (n) {
+        const r = n;
+        throw r.code === 4001 ? new u(
+          c.INVALID_PARAMETER,
+          "User rejected adding chain to wallet."
+        ) : new u(
+          c.INVALID_CHAIN,
+          `Failed to add chain ${i} to wallet: ${r.message || "Unknown error"}`
+        );
+      }
+    throw t.code === 4001 ? new u(
+      c.INVALID_PARAMETER,
+      "User rejected chain switch request."
+    ) : new u(
+      c.INVALID_CHAIN,
+      `Failed to switch to chain ${i}: ${t.message || "Unknown error"}`
+    );
+  }
+}
+async function Et(e) {
+  const i = await e.request({
+    method: "eth_chainId"
+  });
+  return parseInt(i, 16);
+}
+async function m(e, i) {
+  await Et(e) !== i && await Ct(e, i);
+}
+const It = [g.ETHEREUM, g.SEPOLIA], mt = {
+  async getMintingFee(e, i) {
+    return e.capabilities.require("evm").getMintingFee(i, S.BTCb);
+  },
+  async restoreFeeSignature(e, i, s) {
+    const t = await _(
+      S.BTCb,
+      i,
+      e.env
+    ), n = await e.api.getFeeSignature({
+      address: s,
+      chainId: i,
+      tokenAddress: t.address
+    });
+    return !n.hasSignature || n.expirationDate && new Date(Number(n.expirationDate) * 1e3) < /* @__PURE__ */ new Date() ? null : {
+      hasSignature: !0,
+      signature: n.signature,
+      // May be undefined - that's OK
+      typedData: n.typedData
+    };
+  },
+  async authorizeFee(e, { chainId: i, recipient: s, fee: t }) {
+    const n = e.capabilities.require("evm"), r = await e.getProvider("evm");
+    if (!r)
+      throw u.providerMissing(String(i), "evm");
+    await m(r, i);
+    const d = T(t).toString(), A = await _(
+      S.BTCb,
+      i,
+      e.env
+    ), p = await n.signNetworkFee({
+      fee: d,
+      account: s,
+      chainId: i,
+      provider: r,
+      token: S.BTCb
+    });
+    return await e.api.storeFeeSignature({
+      address: s,
+      signature: p.signature,
+      typedData: p.typedData,
+      tokenAddress: A.address
+    }), {
+      signature: p.signature,
+      typedData: p.typedData
+    };
+  }
+}, wt = {
+  chainType: "evm",
+  routes: [
+    {
+      sourceChains: [g.BITCOIN_MAINNET],
+      envs: [h.prod]
+    },
+    {
+      sourceChains: [g.BITCOIN_SIGNET],
+      envs: [h.stage, h.dev, h.testnet, h.ibc]
+    }
+  ],
+  // Derived from ASSET_CATALOG - all chains where BTC.b is deployed
+  destChains: y(f.BTCb).filter(
+    (e) => Q(e)
+  ),
+  // BTC Deposit only produces BTC.b
+  supportedAssetsOut: [f.BTCb],
+  addressSchema: N,
+  /**
+   * Get fee auth config - unsubsidized chains require fee authorization
+   * Other chains use address confirmation signing
+   */
+  getFeeAuthConfig(e) {
+    return It.includes(e) ? mt : null;
+  },
+  /**
+   * Sign destination address confirmation
+   * Used for non-fee-auth chains (e.g., Avalanche, Katana)
+   */
+  async signDestination(e, i, s) {
+    const t = e.capabilities.require("evm"), n = await e.getProvider("evm");
+    if (!n)
+      throw u.providerMissing(String(s), "evm");
+    return await m(n, s), {
+      signature: (await t.signLbtcDestination({
+        address: i,
+        chainId: s,
+        provider: n
+      })).signature
+    };
+  }
+}, C = wt;
+function yt(e) {
+  return C.destChains.includes(e);
+}
+function Tt(e) {
+  return C.supportedAssetsOut.includes(e);
+}
+function _t(e, i) {
+  return e ? C.routes.some(
+    (s) => s.sourceChains.includes(e) && s.envs.includes(i)
+  ) : !0;
+}
+class Nt extends P {
+  constructor(s, t) {
+    super(s, t, a.IDLE);
+    D(this, "chainId");
+    D(this, "authState", { authorized: !1 });
+    /** Fee auth config - null if not required for this destination */
+    D(this, "feeAuthConfig", null);
+    if (!Tt(t.assetOut))
+      throw new u(
+        c.INVALID_ASSET,
+        `Asset ${t.assetOut} is not supported for BTC deposits. BTC Deposit produces BTC.b. For LBTC, use BtcStake instead.`
+      );
+    if (!yt(t.destChain))
+      throw new u(
+        c.INVALID_CHAIN,
+        `Destination chain ${t.destChain} is not supported for BTC deposits. BTC.b is currently available on Avalanche and Katana.`
+      );
+    if (!_t(t.sourceChain, s.env))
+      throw u.routeNotFound({
+        assetOut: t.assetOut,
+        sourceChain: t.sourceChain,
+        destChain: t.destChain,
+        env: s.env
+      });
+    const n = v(t.destChain);
+    if (typeof n != "number" || !b(n))
+      throw new u(
+        c.INVALID_CHAIN,
+        `Unsupported EVM chain: ${t.destChain}`
+      );
+    this.chainId = n;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Abstract Method Implementations
+  // ─────────────────────────────────────────────────────────────────────────
+  getAddressSchema() {
+    return C.addressSchema;
+  }
+  getStatusConfig() {
+    return {
+      idle: a.IDLE,
+      ready: a.READY,
+      addressReady: a.ADDRESS_READY
+    };
+  }
+  getInitialSteps() {
+    return {
+      created: o.IDLE,
+      verifying: o.IDLE,
+      issuing: o.IDLE
+    };
+  }
+  isAuthorized() {
+    return this.authState.authorized;
+  }
+  getChainId() {
+    return this.chainId;
+  }
+  /**
+   * Get the minting fee for this deposit (in BTC)
+   * Available after prepare() when fee authorization is required
+   */
+  get mintingFee() {
+    return this.authState.mintingFee;
+  }
+  getDepositAddressParams() {
+    return {
+      address: this.ensureRecipient(),
+      chainId: this.chainId,
+      signature: this.authState.signature,
+      // Must be set before calling
+      token: this.getExpectedToken(),
+      eip712Data: this.authState.typedData,
+      partnerId: this.ctx.partner.getPartnerId(),
+      referrerCode: this._referralCode
+    };
+  }
+  /**
+   * Override to ensure we have a signature before generating deposit address.
+   * 
+   * When fee auth exists on server but signature isn't available locally,
+   * we fall back to signing the destination address.
+   */
+  async generateDepositAddress() {
+    if (!this.authState.signature) {
+      const s = await C.signDestination(
+        this.ctx,
+        this.ensureRecipient(),
+        this.chainId
+      );
+      this.authState.signature = s.signature, this.authState.typedData = s.typedData;
+    }
+    return this.generateDepositAddressImpl();
+  }
+  /**
+   * Get expected token for this action (BTCb by default for BTC Deposit)
+   */
+  getExpectedToken() {
+    return w(this.params.assetOut, S.BTCb);
+  }
+  getAuthRequiredMessage() {
+    return this.feeAuthConfig ? "Fee authorization required. Call authorizeFee() first." : "Address confirmation required. Call confirmAddress() first.";
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Public Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async prepare(s) {
+    return this.assertStatus(a.IDLE, "prepare"), this.act(async () => {
+      const t = this.validatePrepareParams(s);
+      if (this._amount = t.amount, this._recipient = t.recipient, this._referralCode = t.referralCode, this.feeAuthConfig = C.getFeeAuthConfig(
+        this.params.destChain
+      ), await this.resumeFromExistingDeposit(
+        t.recipient
+      )) {
+        if (this.feeAuthConfig) {
+          const r = await this.feeAuthConfig.restoreFeeSignature(
+            this.ctx,
+            this.chainId,
+            t.recipient
+          );
+          if (!(r != null && r.hasSignature)) {
+            this.authState.mintingFee = await this.feeAuthConfig.getMintingFee(
+              this.ctx,
+              this.chainId
+            ), this.updateStatus(a.NEEDS_FEE_AUTHORIZATION), this.emitInitialProgress();
+            return;
+          }
+          r.signature && (this.authState.signature = r.signature, this.authState.typedData = r.typedData), this.authState.authorized = !0;
+        }
+        this.updateStatus(a.ADDRESS_READY), this.emitInitialProgress();
+        return;
+      }
+      if (this.feeAuthConfig) {
+        const r = await this.feeAuthConfig.restoreFeeSignature(
+          this.ctx,
+          this.chainId,
+          t.recipient
+        );
+        if (r != null && r.hasSignature) {
+          r.signature && (this.authState.signature = r.signature, this.authState.typedData = r.typedData), this.authState.authorized = !0, this.updateStatus(a.READY), this.emitInitialProgress();
+          return;
+        }
+        this.authState.mintingFee = await this.feeAuthConfig.getMintingFee(
+          this.ctx,
+          this.chainId
+        ), this.updateStatus(a.NEEDS_FEE_AUTHORIZATION);
+      } else
+        this.updateStatus(a.NEEDS_ADDRESS_CONFIRMATION);
+      this.emitInitialProgress();
+    });
+  }
+  async authorizeFee() {
+    if (this.assertStatus(
+      [a.NEEDS_FEE_AUTHORIZATION, a.READY],
+      "authorizeFee"
+    ), this.status === a.READY) return;
+    if (!this.feeAuthConfig)
+      throw new u(
+        c.INVALID_PARAMETER,
+        "Fee authorization is not required for this destination chain. Use confirmAddress() instead."
+      );
+    const s = this.ensureRecipient();
+    if (!this.authState.mintingFee)
+      throw new u(
+        c.INVALID_STATE,
+        "Minting fee not available. Call prepare() first."
+      );
+    return this.act(async () => {
+      const t = await this.feeAuthConfig.authorizeFee(this.ctx, {
+        chainId: this.chainId,
+        recipient: s,
+        fee: this.authState.mintingFee
+      });
+      this.authState.signature = t.signature, this.authState.typedData = t.typedData, this.authState.authorized = !0;
+    }, a.READY);
+  }
+  async confirmAddress() {
+    if (this.assertStatus(
+      [a.NEEDS_ADDRESS_CONFIRMATION, a.READY],
+      "confirmAddress"
+    ), this.status === a.READY) return;
+    if (this.feeAuthConfig)
+      throw new u(
+        c.INVALID_PARAMETER,
+        "This destination chain requires fee authorization. Use authorizeFee() instead."
+      );
+    const s = this.ensureRecipient();
+    return this.act(async () => {
+      const t = await C.signDestination(
+        this.ctx,
+        s,
+        this.chainId
+      );
+      this.authState.signature = t.signature, this.authState.typedData = t.typedData, this.authState.authorized = !0;
+    }, a.READY);
+  }
+  async execute() {
+    return this.executeImpl();
+  }
+  async monitorDeposit() {
+    return super.monitorDeposit();
+  }
+}
+const vt = dt.map(
+  (e) => tt(e)
+), Rt = {
+  chainType: "evm",
+  routes: [
+    {
+      sourceChains: [g.BITCOIN_MAINNET],
+      envs: [h.prod]
+    },
+    {
+      sourceChains: [g.BITCOIN_SIGNET],
+      envs: [h.stage, h.dev, h.testnet, h.ibc]
+    }
+  ],
+  // StakeAndDeploy requires vault support - uses VEDA_VAULT_STAKE_AND_BAKE_CHAINS as source of truth
+  destChains: vt,
+  // StakeAndDeploy produces LBTC (then deposits to vault)
+  supportedAssetsOut: [f.LBTC],
+  supportedProtocols: Mt(f.LBTC),
+  addressSchema: N,
+  async getStakeAndBakeFee(e, i, s) {
+    return e.capabilities.require("evm").getStakeAndBakeFee(i, s);
+  },
+  async authorizeStakeAndBake(e, { chainId: i, recipient: s, amount: t, vaultKey: n, token: r }) {
+    const d = e.capabilities.require("evm"), A = await e.getProvider("evm");
+    if (!A)
+      throw u.providerMissing(String(i), "evm");
+    await m(A, i);
+    const p = await d.signStakeAndBake({
+      value: t,
+      account: s,
+      chainId: i,
+      provider: A,
+      vaultKey: n,
+      token: r
+    });
+    return await e.api.storeStakeAndBakeSignature({
+      signature: p.signature,
+      typedData: p.typedData
+    }), {
+      signature: p.signature,
+      typedData: p.typedData
+    };
+  },
+  async restoreStakeAndBakeSignature(e, i, s) {
+    try {
+      const t = await ut({
+        userDestinationAddress: s,
+        chainId: i,
+        env: e.env
+      });
+      return !(t.signature || t.expirationDate) || t.expirationDate && Number(t.expirationDate) * 1e3 < Date.now() ? null : {
+        hasSignature: !0,
+        signature: t.signature,
+        depositAmount: t.depositAmount,
+        expirationDate: t.expirationDate
+      };
+    } catch {
+      return null;
+    }
+  }
+}, l = Rt;
+function Ot(e) {
+  return l.destChains.includes(e);
+}
+function Pt(e) {
+  return l.supportedAssetsOut.includes(e);
+}
+function Lt(e, i) {
+  return e ? l.routes.some(
+    (s) => s.sourceChains.includes(e) && s.envs.includes(i)
+  ) : !0;
+}
+function Y(e) {
+  return e in I;
+}
+function kt(e) {
+  if (!Y(e)) {
+    const i = Object.keys(I).join(", ");
+    throw new Error(
+      `Unsupported protocol: ${e}. Supported protocols: ${i}`
+    );
+  }
+  return e;
+}
+function bt(e) {
+  return Object.entries(I).filter(([i, s]) => e in s).map(([i]) => i);
+}
+const z = {
+  mainnet: [g.AVALANCHE],
+  testnet: [g.AVALANCHE_FUJI]
+}, Bt = {
+  chainType: "evm",
+  routes: [
+    {
+      sourceChains: [g.BITCOIN_MAINNET],
+      envs: [h.prod]
+    },
+    {
+      sourceChains: [g.BITCOIN_SIGNET],
+      envs: [h.stage, h.dev, h.testnet, h.ibc]
+    }
+  ],
+  // DepositAndDeploy with BTC.b is available on Avalanche
+  destChains: [
+    ...z.mainnet,
+    ...z.testnet
+  ],
+  // DepositAndDeploy produces BTC.b (then deposits to vault)
+  supportedAssetsOut: [f.BTCb],
+  supportedProtocols: bt(f.BTCb),
+  addressSchema: N,
+  async getDepositAndDeployFee(e, i, s) {
+    return e.capabilities.require("evm").getStakeAndBakeFee(i, s);
+  },
+  async authorizeDepositAndDeploy(e, { chainId: i, recipient: s, amount: t, vaultKey: n, token: r }) {
+    const d = e.capabilities.require("evm"), A = await e.getProvider("evm");
+    if (!A)
+      throw u.providerMissing(String(i), "evm");
+    await m(A, i);
+    const p = await d.signStakeAndBake({
+      value: t,
+      account: s,
+      chainId: i,
+      provider: A,
+      vaultKey: n,
+      token: r
+    });
+    return await e.api.storeStakeAndBakeSignature({
+      signature: p.signature,
+      typedData: p.typedData
+    }), {
+      signature: p.signature,
+      typedData: p.typedData,
+      // approvalTxHash may not be present in the result for all flows
+      approvalTxHash: p.approvalTxHash
+    };
+  }
+}, E = Bt;
+function Ft(e) {
+  return E.destChains.includes(e);
+}
+function xt(e) {
+  return E.supportedAssetsOut.includes(e);
+}
+function $(e) {
+  return e in I;
+}
+function H(e) {
+  if (!$(e)) {
+    const i = Object.keys(I).join(", ");
+    throw new Error(
+      `Unsupported protocol: ${e}. Supported protocols: ${i}`
+    );
+  }
+  return e;
+}
+function Mt(e) {
+  return Object.entries(I).filter(([i, s]) => e in s).map(([i]) => i);
+}
+function zt(e, i) {
+  return E.routes.some(
+    (s) => s.sourceChains.includes(e) && s.envs.includes(i)
+  );
+}
+class Ht extends P {
+  constructor(s, t) {
+    super(s, t, a.IDLE);
+    D(this, "chainId");
+    D(this, "authState", { authorized: !1 });
+    if (!xt(t.assetOut))
+      throw new u(
+        c.INVALID_ASSET,
+        `Asset ${t.assetOut} is not supported for deposit and deploy. DepositAndDeploy produces BTC.b which is then deployed to a vault like Silo.`
+      );
+    if (!Ft(t.destChain))
+      throw new u(
+        c.INVALID_CHAIN,
+        `Destination chain ${t.destChain} is not supported for deposit and deploy. Supported chains: Avalanche, Avalanche Fuji`
+      );
+    if (!$(t.protocol))
+      throw new u(
+        c.INVALID_PARAMETER,
+        `Protocol ${t.protocol} is not supported for deposit and deploy. DepositAndDeploy with BTC.b only supports Silo protocol.`
+      );
+    const n = t.sourceChain ?? g.BITCOIN_MAINNET;
+    if (!zt(n, s.env))
+      throw u.routeNotFound({
+        assetOut: t.assetOut,
+        sourceChain: n,
+        destChain: t.destChain,
+        env: s.env
+      });
+    const r = v(t.destChain);
+    if (typeof r != "number" || !b(r))
+      throw new u(
+        c.INVALID_CHAIN,
+        `Unsupported EVM chain: ${t.destChain}`
+      );
+    this.chainId = r;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Abstract Method Implementations
+  // ─────────────────────────────────────────────────────────────────────────
+  getAddressSchema() {
+    return E.addressSchema;
+  }
+  getStatusConfig() {
+    return {
+      idle: a.IDLE,
+      ready: a.READY,
+      addressReady: a.ADDRESS_READY
+    };
+  }
+  getInitialSteps() {
+    return {
+      created: o.IDLE,
+      verifying: o.IDLE,
+      wrapping: o.IDLE,
+      depositing: o.IDLE
+    };
+  }
+  isAuthorized() {
+    return this.authState.authorized;
+  }
+  getChainId() {
+    return this.chainId;
+  }
+  getDepositAddressParams() {
+    return {
+      address: this.ensureRecipient(),
+      chainId: this.chainId,
+      signature: this.authState.signature,
+      token: this.getExpectedToken(),
+      // Deposit and deploy uses signatureData (maps to sb_signature_data), not eip712Data
+      signatureData: this.authState.typedData,
+      partnerId: this.ctx.partner.getPartnerId(),
+      referrerCode: this._referralCode
+    };
+  }
+  /**
+   * Get expected token for this action (BTCb by default for DepositAndDeploy)
+   */
+  getExpectedToken() {
+    return w(this.params.assetOut, S.BTCb);
+  }
+  getAuthRequiredMessage() {
+    return "Deposit authorization required. Call authorizeDeposit() first.";
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Public Getters
+  // ─────────────────────────────────────────────────────────────────────────
+  /** Get deposit and deploy fee (available after prepare()) */
+  get fee() {
+    return this.authState.fee;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Public Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async prepare(s) {
+    return this.assertStatus(a.IDLE, "prepare"), this.act(async () => {
+      const t = this.validatePrepareParams(s);
+      this._amount = t.amount, this._recipient = t.recipient, this._referralCode = t.referralCode, this.authState.fee = await E.getDepositAndDeployFee(
+        this.ctx,
+        this.chainId,
+        H(this.params.protocol)
+      ), this.updateStatus(a.NEEDS_DEPLOY_AUTHORIZATION), this.emitInitialProgress();
+    }, a.NEEDS_DEPLOY_AUTHORIZATION);
+  }
+  async authorizeDeposit() {
+    if (this.assertStatus(
+      [a.NEEDS_DEPLOY_AUTHORIZATION, a.READY],
+      "authorizeDeposit"
+    ), this.status === a.READY) return;
+    const s = this.ensureRecipient(), t = this.ensureAmount();
+    return this.act(async () => {
+      const n = T(t), r = w(this.params.assetOut, S.BTCb), d = await E.authorizeDepositAndDeploy(
+        this.ctx,
+        {
+          chainId: this.chainId,
+          recipient: s,
+          amount: n.toString(),
+          vaultKey: H(this.params.protocol),
+          token: r
+        }
+      );
+      this.authState.signature = d.signature, this.authState.typedData = d.typedData, this.authState.authorized = !0;
+    }, a.READY);
+  }
+  async generateDepositAddress() {
+    return this.assertStatus(a.READY, "generateDepositAddress"), this.ensureAuthorized(), this._depositAddress ? this._depositAddress : this.act(async () => {
+      const s = this.getDepositAddressParams(), t = await this.ctx.api.generateDepositAddress(s);
+      return O(t), this._depositAddress = t, this.emitProgress({
+        status: a.ADDRESS_READY,
+        steps: {
+          created: o.COMPLETE,
+          verifying: o.IDLE,
+          wrapping: o.IDLE,
+          depositing: o.IDLE
+        },
+        metadata: { depositAddress: t }
+      }), t;
+    }, a.ADDRESS_READY);
+  }
+  async execute() {
+    return this.act(async () => {
+      this.assertStatus(a.ADDRESS_READY, "execute"), this._depositAddress || await this.generateDepositAddress();
+      const s = this.ensureDepositAddress(), t = await this.trySendBitcoin(s);
+      return t ? { depositAddress: s, txHash: t } : { depositAddress: s };
+    });
+  }
+  // Custom monitorDeposit with different step names
+  async monitorDeposit() {
+    const s = this._depositAddress, t = this._recipient;
+    if (!s || !t)
+      throw u.missingParameter("depositAddress or recipient");
+    return await B({
+      network: this.bitcoinNetwork,
+      btcService: this.ctx.btc,
+      fetchDeposit: async () => {
+        const d = (await this.ctx.api.getDeposits(t)).find(
+          (A) => A.depositAddress === s
+        );
+        if (d)
+          return {
+            blockHeight: d.blockHeight,
+            isClaimed: d.isClaimed
+          };
+      },
+      onProgress: (r) => {
+        this.emitProgress({
+          status: this.status,
+          steps: {
+            created: o.COMPLETE,
+            verifying: r.hasEnoughConfirmations ? o.COMPLETE : o.PENDING,
+            wrapping: r.isClaimed ? o.COMPLETE : o.PENDING,
+            depositing: o.PENDING
+          },
+          confirmations: r.confirmations,
+          requiredConfirmations: r.requiredConfirmations,
+          metadata: { isClaimed: r.isClaimed }
+        });
+      },
+      onComplete: () => {
+        this.emitCompleted();
+      }
+    });
+  }
+}
+const L = (e) => `${e}${et}`;
+function Yt(e) {
+  return String(e).startsWith(L(R.EIP155));
+}
+function $t(e) {
+  return String(e).startsWith(L(R.SOLANA));
+}
+function qt(e) {
+  return String(e).startsWith(L(R.SUI));
+}
+function Vt(e) {
+  return String(e).startsWith(L(R.STARKNET));
+}
+const Ut = [g.ETHEREUM, g.SEPOLIA], Gt = {
+  async getMintingFee(e, i) {
+    return e.capabilities.require("evm").getMintingFee(i);
+  },
+  async restoreFeeSignature(e, i, s) {
+    const t = await _(
+      S.LBTC,
+      i,
+      e.env
+    ), n = await e.api.getFeeSignature({
+      address: s,
+      chainId: i,
+      tokenAddress: t.address
+    });
+    return !n.hasSignature || n.expirationDate && new Date(Number(n.expirationDate) * 1e3) < /* @__PURE__ */ new Date() ? null : {
+      hasSignature: !0,
+      signature: n.signature,
+      // May be undefined - that's OK
+      typedData: n.typedData
+    };
+  },
+  async authorizeFee(e, { chainId: i, recipient: s, fee: t }) {
+    const n = e.capabilities.require("evm"), r = await e.getProvider("evm");
+    if (!r)
+      throw u.providerMissing(String(i), "evm");
+    await m(r, i);
+    const d = T(t).toString(), A = await _(
+      S.LBTC,
+      i,
+      e.env
+    ), p = await n.signNetworkFee({
+      fee: d,
+      account: s,
+      chainId: i,
+      provider: r,
+      token: S.LBTC
+    });
+    return await e.api.storeFeeSignature({
+      address: s,
+      signature: p.signature,
+      typedData: p.typedData,
+      tokenAddress: A.address
+    }), {
+      signature: p.signature,
+      typedData: p.typedData
+    };
+  }
+}, Kt = {
+  chainType: "evm",
+  routes: [
+    {
+      sourceChains: [g.BITCOIN_MAINNET],
+      envs: [h.prod]
+    },
+    {
+      sourceChains: [g.BITCOIN_SIGNET],
+      envs: [h.testnet, h.stage, h.dev, h.ibc]
+    }
+  ],
+  // Derived from ASSET_CATALOG - all EVM chains where LBTC is deployed
+  // Note: This includes all chains across all environments
+  // The `routes` config above filters by source chain + env
+  destChains: y(f.LBTC).filter((e) => Yt(e)),
+  // BTC Stake only produces LBTC
+  supportedAssetsOut: [f.LBTC],
+  addressSchema: N,
+  getFeeAuthConfig(e) {
+    return Ut.includes(e) ? Gt : null;
+  },
+  async getSignature(e, i, s) {
+    const t = e.capabilities.require("evm"), n = await e.getProvider("evm");
+    if (!n)
+      throw u.providerMissing(String(s), "evm");
+    return await m(n, s), t.signLbtcDestination({
+      chainId: s,
+      address: i,
+      provider: n
+    });
+  }
+};
+function jt(e) {
+  const i = {
+    // CAIP-2 format using genesis hash
+    [g.SOLANA_MAINNET]: "mainnet-beta",
+    [g.SOLANA_DEVNET]: "devnet",
+    [g.SOLANA_TESTNET]: "testnet",
+    // Legacy format (solana:network-name)
+    "solana:mainnet-beta": "mainnet-beta",
+    "solana:devnet": "devnet",
+    "solana:testnet": "testnet"
+  }, s = i[e];
+  if (!s)
+    throw new u(
+      c.INVALID_CHAIN,
+      `Unknown Solana chain: ${e}. Expected one of: ${Object.keys(i).join(", ")}`
+    );
+  return s;
+}
+const Zt = {
+  chainType: "solana",
+  routes: [
+    {
+      sourceChains: [g.BITCOIN_MAINNET],
+      envs: [h.prod]
+    },
+    {
+      sourceChains: [g.BITCOIN_SIGNET],
+      envs: [h.testnet, h.stage, h.dev, h.ibc]
+    }
+  ],
+  // Derived from ASSET_CATALOG - Solana chains where LBTC is deployed
+  destChains: y(f.LBTC).filter(
+    (e) => $t(e)
+  ),
+  // BTC Stake only produces LBTC
+  supportedAssetsOut: [f.LBTC],
+  addressSchema: st,
+  // Solana never requires fee authorization
+  getFeeAuthConfig: () => null,
+  async getSignature(e, i, s) {
+    const t = e.capabilities.require("solana"), n = jt(s), { signature: r } = await t.signLbtcDestination({
+      network: n
+    });
+    return { signature: r };
+  }
+}, Wt = {
+  chainType: "starknet",
+  routes: [
+    {
+      sourceChains: [g.BITCOIN_MAINNET],
+      envs: [h.prod]
+    },
+    {
+      sourceChains: [g.BITCOIN_SIGNET],
+      envs: [h.testnet, h.stage, h.dev, h.ibc]
+    }
+  ],
+  // Derived from ASSET_CATALOG - Starknet chains where LBTC is deployed
+  destChains: y(f.LBTC).filter(
+    (e) => Vt(e)
+  ),
+  // BTC Stake only produces LBTC
+  supportedAssetsOut: [f.LBTC],
+  addressSchema: it,
+  // Starknet never requires fee authorization
+  getFeeAuthConfig: () => null,
+  async getSignature(e, i, s) {
+    const t = e.capabilities.require("starknet"), { signature: n, pubKey: r } = await t.signLbtcDestination({
+      chainId: s
+    }), d = ht(i, { size: 32 });
+    return { signature: n, pubKey: r, paddedAddress: d };
+  }
+}, Xt = {
+  chainType: "sui",
+  routes: [
+    {
+      sourceChains: [g.BITCOIN_MAINNET],
+      envs: [h.prod]
+    },
+    {
+      sourceChains: [g.BITCOIN_SIGNET],
+      envs: [h.testnet, h.stage, h.dev, h.ibc]
+    }
+  ],
+  // Derived from ASSET_CATALOG - Sui chains where LBTC is deployed
+  destChains: y(f.LBTC).filter(
+    (e) => qt(e)
+  ),
+  // BTC Stake only produces LBTC
+  supportedAssetsOut: [f.LBTC],
+  addressSchema: rt,
+  // Sui never requires fee authorization
+  getFeeAuthConfig: () => null,
+  async getSignature(e, i, s) {
+    const t = e.capabilities.require("sui"), { signature: n } = await t.signLbtcDestination({
+      chainId: s
+    });
+    return { signature: n };
+  }
+}, Jt = {
+  evm: Kt,
+  solana: Zt,
+  sui: Xt,
+  starknet: Wt
+};
+function Qt(e) {
+  return Jt[e];
+}
+function te(e, i, s) {
+  return i ? e.routes.some(
+    (t) => t.sourceChains.includes(i) && t.envs.includes(s)
+  ) : !0;
+}
+function ee(e, i) {
+  return e.destChains.includes(i);
+}
+function se(e, i) {
+  return e.supportedAssetsOut.includes(i);
+}
+class ie extends P {
+  constructor(s, t) {
+    super(s, t, a.IDLE);
+    D(this, "config");
+    D(this, "chainId");
+    D(this, "authState", { authorized: !1 });
+    /** Fee auth config - null if not required for this destination */
+    D(this, "feeAuthConfig", null);
+    const n = nt(t.destChain), r = Qt(n);
+    if (!r)
+      throw new u(
+        c.INVALID_CHAIN,
+        `Unsupported destination chain type: ${n} (${t.destChain})`
+      );
+    if (!se(r, t.assetOut))
+      throw new u(
+        c.INVALID_ASSET,
+        `Asset ${t.assetOut} is not supported for BTC staking. BTC Stake produces LBTC. For BTC.b, use BtcDeposit instead.`
+      );
+    if (!ee(r, t.destChain))
+      throw new u(
+        c.INVALID_CHAIN,
+        `Destination chain ${t.destChain} is not supported for ${n}`
+      );
+    if (!te(r, t.sourceChain, s.env))
+      throw u.routeNotFound({
+        assetOut: t.assetOut,
+        sourceChain: t.sourceChain,
+        destChain: t.destChain,
+        env: s.env
+      });
+    this.config = r, this.chainId = v(t.destChain);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Abstract Method Implementations
+  // ─────────────────────────────────────────────────────────────────────────
+  getAddressSchema() {
+    return this.config.addressSchema;
+  }
+  getStatusConfig() {
+    return {
+      idle: a.IDLE,
+      ready: a.READY,
+      addressReady: a.ADDRESS_READY
+    };
+  }
+  getInitialSteps() {
+    return {
+      created: o.IDLE,
+      verifying: o.IDLE,
+      issuing: o.IDLE
+    };
+  }
+  isAuthorized() {
+    return this.authState.authorized;
+  }
+  getChainId() {
+    return this.chainId;
+  }
+  getDepositAddressParams() {
+    var n;
+    const s = this.ensureRecipient(), t = this.getActiveSignature();
+    if (!t)
+      throw new u(
+        c.INVALID_PARAMETER,
+        "Missing signature. Complete authorization first."
+      );
+    return {
+      address: t.paddedAddress ?? s,
+      chainId: this.chainId,
+      signature: t.signature,
+      token: this.getExpectedToken(),
+      eip712Data: (n = this.authState.networkFee) == null ? void 0 : n.typedData,
+      pubKey: t.pubKey,
+      partnerId: this.ctx.partner.getPartnerId(),
+      referrerCode: this._referralCode
+    };
+  }
+  /**
+   * Get expected token for this action (LBTC by default for BTC Stake)
+   */
+  getExpectedToken() {
+    return w(this.params.assetOut, S.LBTC);
+  }
+  getAuthRequiredMessage() {
+    return "Authorization required. Call authorize() first.";
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Public Getters
+  // ─────────────────────────────────────────────────────────────────────────
+  /** Get minting fee (available after prepare() for fee-auth chains) */
+  get mintingFee() {
+    return this.authState.mintingFee;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Public Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async prepare(s) {
+    return this.assertStatus(a.IDLE, "prepare"), this.act(async () => {
+      const t = this.validatePrepareParams(s);
+      if (this._amount = t.amount, this._recipient = t.recipient, this._referralCode = t.referralCode, this.feeAuthConfig = this.config.getFeeAuthConfig(this.params.destChain), await this.resumeFromExistingDeposit(
+        t.recipient
+      )) {
+        if (this.feeAuthConfig) {
+          const r = await this.feeAuthConfig.restoreFeeSignature(
+            this.ctx,
+            this.chainId,
+            t.recipient
+          );
+          if (!(r != null && r.hasSignature)) {
+            this.authState.mintingFee = await this.feeAuthConfig.getMintingFee(
+              this.ctx,
+              this.chainId
+            ), this.updateStatus(a.NEEDS_FEE_AUTHORIZATION), this.emitInitialProgress();
+            return;
+          }
+          r.signature && (this.authState.networkFee = {
+            signature: r.signature,
+            typedData: r.typedData
+          }), this.authState.authorized = !0;
+        }
+        this.updateStatus(a.ADDRESS_READY), this.emitInitialProgress();
+        return;
+      }
+      if (this.feeAuthConfig) {
+        const r = await this.feeAuthConfig.restoreFeeSignature(
+          this.ctx,
+          this.chainId,
+          t.recipient
+        );
+        if (r != null && r.hasSignature) {
+          r.signature && (this.authState.networkFee = {
+            signature: r.signature,
+            typedData: r.typedData
+          }), this.authState.authorized = !0, this.updateStatus(a.READY), this.emitInitialProgress();
+          return;
+        }
+        this.authState.mintingFee = await this.feeAuthConfig.getMintingFee(
+          this.ctx,
+          this.chainId
+        ), this.updateStatus(a.NEEDS_FEE_AUTHORIZATION);
+      } else
+        this.updateStatus(a.NEEDS_ADDRESS_CONFIRMATION);
+      this.emitInitialProgress();
+    });
+  }
+  async authorize() {
+    if (this.assertStatus(
+      [
+        a.NEEDS_FEE_AUTHORIZATION,
+        a.NEEDS_ADDRESS_CONFIRMATION,
+        a.READY
+      ],
+      "authorize"
+    ), this.status === a.READY) return;
+    const s = this.ensureRecipient(), t = this.feeAuthConfig !== null;
+    return this.act(async () => {
+      if (t) {
+        const n = this.ensureMintingFee(), r = await this.feeAuthConfig.authorizeFee(this.ctx, {
+          chainId: this.chainId,
+          recipient: s,
+          fee: n
+        });
+        this.authState.networkFee = {
+          signature: r.signature,
+          typedData: r.typedData
+        };
+      } else
+        this.authState.destinationSignature = await this.config.getSignature(
+          this.ctx,
+          s,
+          this.chainId
+        );
+      this.authState.authorized = !0;
+    }, a.READY);
+  }
+  async generateDepositAddress() {
+    if (this.assertStatus(a.READY, "generateDepositAddress"), this.ensureAuthorized(), this._depositAddress)
+      return this._depositAddress;
+    if (!this.getActiveSignature()) {
+      const s = await this.config.getSignature(
+        this.ctx,
+        this.ensureRecipient(),
+        this.chainId
+      );
+      this.authState.destinationSignature = s;
+    }
+    return this.act(async () => {
+      const s = this.getDepositAddressParams(), t = await this.ctx.api.generateDepositAddress(s);
+      return O(t), this._depositAddress = t, this.emitProgress({
+        status: a.ADDRESS_READY,
+        steps: {
+          created: o.COMPLETE,
+          verifying: o.IDLE,
+          issuing: o.IDLE
+        },
+        metadata: { depositAddress: t }
+      }), t;
+    }, a.ADDRESS_READY);
+  }
+  async execute() {
+    return this.executeImpl();
+  }
+  async monitorDeposit() {
+    return super.monitorDeposit();
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Private: Ensure Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  ensureMintingFee() {
+    if (!this.authState.mintingFee)
+      throw new u(
+        c.INVALID_PARAMETER,
+        "Minting fee not fetched. Call prepare() first."
+      );
+    return this.authState.mintingFee;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Private: Signature Helpers
+  // ─────────────────────────────────────────────────────────────────────────
+  getActiveSignature() {
+    var s;
+    return (s = this.authState.networkFee) != null && s.signature ? { signature: this.authState.networkFee.signature } : this.authState.destinationSignature;
+  }
+}
+class re extends P {
+  constructor(s, t) {
+    super(s, t, a.IDLE);
+    D(this, "chainId");
+    D(this, "authState", { authorized: !1 });
+    if (!Pt(t.assetOut))
+      throw new u(
+        c.INVALID_ASSET,
+        `Asset ${t.assetOut} is not supported for stake and deploy. StakeAndDeploy produces LBTC which is then deployed to a vault.`
+      );
+    if (!Ot(t.destChain))
+      throw new u(
+        c.INVALID_CHAIN,
+        `Destination chain ${t.destChain} is not supported for stake and deploy`
+      );
+    if (!Y(t.protocol))
+      throw new u(
+        c.INVALID_PARAMETER,
+        `Protocol ${t.protocol} is not supported for stake and deploy`
+      );
+    if (!Lt(t.sourceChain, s.env))
+      throw u.routeNotFound({
+        assetOut: t.assetOut,
+        sourceChain: t.sourceChain,
+        destChain: t.destChain,
+        env: s.env
+      });
+    const n = v(t.destChain);
+    if (typeof n != "number" || !b(n))
+      throw new u(
+        c.INVALID_CHAIN,
+        `Unsupported EVM chain: ${t.destChain}`
+      );
+    this.chainId = n;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Abstract Method Implementations
+  // ─────────────────────────────────────────────────────────────────────────
+  getAddressSchema() {
+    return l.addressSchema;
+  }
+  getStatusConfig() {
+    return {
+      idle: a.IDLE,
+      ready: a.READY,
+      addressReady: a.ADDRESS_READY
+    };
+  }
+  getInitialSteps() {
+    return {
+      created: o.IDLE,
+      verifying: o.IDLE,
+      issuing: o.IDLE,
+      depositing: o.IDLE
+    };
+  }
+  isAuthorized() {
+    return this.authState.authorized;
+  }
+  getChainId() {
+    return this.chainId;
+  }
+  getDepositAddressParams() {
+    return {
+      address: this.ensureRecipient(),
+      chainId: this.chainId,
+      signature: this.authState.signature,
+      token: this.getExpectedToken(),
+      // Stake and bake uses signatureData (maps to sb_signature_data), not eip712Data
+      signatureData: this.authState.typedData,
+      partnerId: this.ctx.partner.getPartnerId(),
+      referrerCode: this._referralCode
+    };
+  }
+  /**
+   * Get expected token for this action (LBTC by default for StakeAndDeploy)
+   */
+  getExpectedToken() {
+    return w(this.params.assetOut, S.LBTC);
+  }
+  getAuthRequiredMessage() {
+    return "Deposit authorization required. Call authorizeDeposit() first.";
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Public Getters
+  // ─────────────────────────────────────────────────────────────────────────
+  /** Get stake and bake fee (available after prepare()) */
+  get fee() {
+    return this.authState.fee;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Public Methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async prepare(s) {
+    return this.assertStatus(a.IDLE, "prepare"), this.act(async () => {
+      const t = this.validatePrepareParams(s);
+      if (this._amount = t.amount, this._recipient = t.recipient, this._referralCode = t.referralCode, this.authState.fee = await l.getStakeAndBakeFee(
+        this.ctx,
+        this.chainId,
+        this.params.protocol
+      ), await this.resumeFromExistingDeposit(
+        t.recipient
+      )) {
+        const d = await l.restoreStakeAndBakeSignature(
+          this.ctx,
+          this.chainId,
+          t.recipient
+        );
+        if (d != null && d.hasSignature) {
+          d.signature && (this.authState.signature = d.signature), this.authState.authorized = !0, this.updateStatus(a.ADDRESS_READY), this.emitInitialProgress();
+          return;
+        }
+        this.updateStatus(a.NEEDS_DEPLOY_AUTHORIZATION), this.emitInitialProgress();
+        return;
+      }
+      const r = await l.restoreStakeAndBakeSignature(
+        this.ctx,
+        this.chainId,
+        t.recipient
+      );
+      if (r != null && r.hasSignature) {
+        r.signature && (this.authState.signature = r.signature), this.authState.authorized = !0, this.updateStatus(a.READY), this.emitInitialProgress();
+        return;
+      }
+      this.updateStatus(a.NEEDS_DEPLOY_AUTHORIZATION), this.emitInitialProgress();
+    });
+  }
+  async authorizeDeposit() {
+    if (this.assertStatus(
+      [a.NEEDS_DEPLOY_AUTHORIZATION, a.READY],
+      "authorizeDeposit"
+    ), this.status === a.READY) return;
+    const s = this.ensureRecipient(), t = this.ensureAmount();
+    return this.act(async () => {
+      const n = T(t), r = this.params.assetIn ?? f.BTC, d = await l.authorizeStakeAndBake(
+        this.ctx,
+        {
+          chainId: this.chainId,
+          recipient: s,
+          amount: n.toString(),
+          vaultKey: kt(this.params.protocol),
+          token: r
+        }
+      );
+      this.authState.signature = d.signature, this.authState.typedData = d.typedData, this.authState.authorized = !0;
+    }, a.READY);
+  }
+  async generateDepositAddress() {
+    return this.assertStatus(a.READY, "generateDepositAddress"), this.ensureAuthorized(), this._depositAddress ? this._depositAddress : this.act(async () => {
+      const s = this.getDepositAddressParams(), t = await this.ctx.api.generateDepositAddress(s);
+      return O(t), this._depositAddress = t, this.emitProgress({
+        status: a.ADDRESS_READY,
+        steps: {
+          created: o.COMPLETE,
+          verifying: o.IDLE,
+          issuing: o.IDLE,
+          depositing: o.IDLE
+        },
+        metadata: { depositAddress: t }
+      }), t;
+    }, a.ADDRESS_READY);
+  }
+  async execute() {
+    return this.act(async () => {
+      this.assertStatus(a.ADDRESS_READY, "execute"), this._depositAddress || await this.generateDepositAddress();
+      const s = this.ensureDepositAddress(), t = await this.trySendBitcoin(s);
+      return t ? { depositAddress: s, txHash: t } : { depositAddress: s };
+    });
+  }
+  // Custom monitorDeposit with different step names
+  async monitorDeposit() {
+    const s = this._depositAddress, t = this._recipient;
+    if (!s || !t)
+      throw u.missingParameter("depositAddress or recipient");
+    return await B({
+      network: this.bitcoinNetwork,
+      btcService: this.ctx.btc,
+      fetchDeposit: async () => {
+        const d = (await this.ctx.api.getDeposits(t)).find(
+          (A) => A.depositAddress === s
+        );
+        if (d)
+          return {
+            blockHeight: d.blockHeight,
+            isClaimed: d.isClaimed
+          };
+      },
+      onProgress: (r) => {
+        this.emitProgress({
+          status: this.status,
+          steps: {
+            created: o.COMPLETE,
+            verifying: r.hasEnoughConfirmations ? o.COMPLETE : o.PENDING,
+            issuing: r.isClaimed ? o.COMPLETE : o.PENDING,
+            depositing: o.PENDING
+          },
+          confirmations: r.confirmations,
+          requiredConfirmations: r.requiredConfirmations,
+          metadata: { isClaimed: r.isClaimed }
+        });
+      },
+      onComplete: () => {
+        this.emitCompleted();
+      }
+    });
+  }
+}
+class ne {
+  constructor(i) {
+    D(this, "ctx");
+    this.ctx = at(i);
+  }
+  /**
+   * Stake BTC → LBTC
+   *
+   * Creates a stake operation for converting BTC to LBTC on a destination chain.
+   * Supports all destination chains: EVM, Solana, Sui, and Starknet.
+   *
+   * @param params - Stake parameters
+   * @returns BtcStake instance
+   *
+   * @example
+   * ```typescript
+   * const stake = btc.stake({
+   *   assetOut: AssetId.LBTC,
+   *   destChain: Chain.ETHEREUM,
+   * });
+   *
+   * await stake.prepare({ amount: '0.1', recipient: '0x...' });
+   * await stake.authorize();
+   * const address = await stake.generateDepositAddress();
+   * ```
+   */
+  stake(i) {
+    return new ie(this.ctx, i);
+  }
+  /**
+   * Stake and Deploy BTC → LBTC + auto-deploy ("Stake and Bake")
+   *
+   * Creates an atomic operation that:
+   * 1. Converts BTC to LBTC
+   * 2. Automatically deposits LBTC to the specified DeFi vault
+   *
+   * @param params - StakeAndDeploy parameters including protocol/vault
+   * @returns BtcStakeAndDeploy instance
+   *
+   * @example
+   * ```typescript
+   * const action = btc.stakeAndDeploy({
+   *   assetOut: AssetId.LBTC,
+   *   destChain: Chain.ETHEREUM,
+   *   protocol: DeployProtocol.Veda,
+   * });
+   *
+   * await action.prepare({ amount: '0.1', recipient: '0x...' });
+   * await action.authorizeDeposit();
+   * const address = await action.generateDepositAddress();
+   * ```
+   */
+  stakeAndDeploy(i) {
+    return new re(this.ctx, i);
+  }
+  /**
+   * Deposit BTC for custody (BTC → BTC.b)
+   *
+   * Creates a deposit operation for custodying BTC with BTC.b minting.
+   * This is for custody without staking. For staking (BTC → LBTC), use stake().
+   *
+   * @param params - Deposit parameters
+   * @returns BtcDeposit instance
+   *
+   * @example
+   * ```typescript
+   * const deposit = btc.deposit({
+   *   assetOut: AssetId.BTCb,
+   *   destChain: Chain.AVALANCHE,
+   * });
+   *
+   * await deposit.prepare({ amount: '0.1', recipient: '0x...' });
+   * await deposit.authorizeFee();
+   * const address = await deposit.generateDepositAddress();
+   * ```
+   */
+  deposit(i) {
+    return new Nt(this.ctx, i);
+  }
+  /**
+   * Deposit and Deploy BTC → BTC.b + auto-deploy to vault
+   *
+   * Creates an atomic operation that:
+   * 1. Converts BTC to BTC.b (wrapped BTC)
+   * 2. Automatically deposits BTC.b to the specified DeFi vault (e.g., Silo on Avalanche)
+   *
+   * This is similar to stakeAndDeploy but for protocols that accept BTC.b instead of LBTC.
+   *
+   * @param params - DepositAndDeploy parameters including protocol/vault
+   * @returns BtcDepositAndDeploy instance
+   *
+   * @example
+   * ```typescript
+   * const action = btc.depositAndDeploy({
+   *   assetOut: AssetId.BTCb,
+   *   destChain: Chain.AVALANCHE,
+   *   protocol: DeployProtocol.Silo,
+   * });
+   *
+   * await action.prepare({ amount: '0.1', recipient: '0x...' });
+   * await action.authorizeDeposit();
+   * const address = await action.generateDepositAddress();
+   * ```
+   */
+  depositAndDeploy(i) {
+    return new Ht(this.ctx, i);
+  }
+}
+function le(e) {
+  return new ne(e);
+}
+export {
+  ne as B,
+  Se as a,
+  le as b,
+  Nt as c,
+  Ht as d,
+  ie as e,
+  re as f
+};
+//# sourceMappingURL=BtcActions-DGqmtxjd.js.map