@babylonlabs-io/ts-sdk 0.0.0-semantic-release.2 → 0.1.0

package/dist/PayoutManager-rMj54HDh.js

@@ -0,0 +1,1112 @@
+var X = Object.defineProperty;
+var L = (n, t, e) => t in n ? X(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var I = (n, t, e) => L(n, typeof t != "symbol" ? t + "" : t, e);
+import * as $ from "bitcoinjs-lib";
+import { script as D, Transaction as E, address as q, Psbt as S } from "bitcoinjs-lib";
+import { Buffer as p } from "buffer";
+import { m as C, s as T, b as z, k as j, v as A, a as O, e as W } from "./challengeAssert-DVErOd8l.js";
+import { createPublicClient as F, http as M, encodeFunctionData as Y, zeroAddress as J } from "viem";
+import "@babylonlabs-io/babylon-tbv-rust-wasm";
+import "@bitcoin-js/tiny-secp256k1-asmjs";
+const Z = 58, V = 43, G = 11, N = 546, H = BigInt(N), Q = 30, tt = 2, mt = 1.1;
+function et(n) {
+  return n <= tt ? Q : 0;
+}
+function nt(n, t, e) {
+  if (n.length === 0)
+    throw new Error("Insufficient funds: no UTXOs available");
+  const s = n.filter((r) => {
+    const c = p.from(r.scriptPubKey, "hex");
+    return !!D.decompile(c);
+  });
+  if (s.length === 0)
+    throw new Error(
+      "Insufficient funds: no valid UTXOs available (all have invalid scripts)"
+    );
+  const a = [...s].sort((r, c) => c.value - r.value), o = [];
+  let u = 0n, i = 0n;
+  for (const r of a) {
+    o.push(r), u += BigInt(r.value);
+    const c = o.length * Z, l = 2 * V, d = c + l + G;
+    if (i = BigInt(Math.ceil(d * e)) + BigInt(et(e)), u - t - i > H) {
+      const g = BigInt(
+        Math.ceil(V * e)
+      );
+      i += g;
+    }
+    if (u >= t + i) {
+      const g = u - t - i;
+      return {
+        selectedUTXOs: o,
+        totalValue: u,
+        fee: i,
+        changeAmount: g
+      };
+    }
+  }
+  throw new Error(
+    `Insufficient funds: need ${t + i} sats (${t} pegin + ${i} fee), have ${u} sats`
+  );
+}
+function wt(n) {
+  return n > H;
+}
+function xt() {
+  return N;
+}
+function st(n) {
+  const e = n.substring(8, 12) === "0001" ? 12 : 8, s = parseInt(
+    n.substring(e, e + 2),
+    16
+  ), a = parseInt(
+    n.substring(e + 2, e + 4),
+    16
+  );
+  if (s !== 0)
+    throw new Error(`Expected 0 inputs from WASM, got ${s}`);
+  if (a === 0)
+    throw new Error("Expected at least 1 output from WASM, got 0");
+  const o = p.from(n.substring(0, 8), "hex").readUInt32LE(0), u = p.from(
+    n.substring(n.length - 8),
+    "hex"
+  ).readUInt32LE(0), i = [];
+  let r = e + 4;
+  for (let c = 0; c < a; c++) {
+    const l = n.substring(r, r + 16), d = Number(p.from(l, "hex").readBigUInt64LE(0));
+    r += 16;
+    const f = parseInt(n.substring(r, r + 2), 16);
+    r += 2;
+    const g = n.substring(r, r + f * 2), b = p.from(g, "hex");
+    r += f * 2, i.push({ value: d, script: b });
+  }
+  return { version: o, locktime: u, outputs: i };
+}
+function rt(n) {
+  const { unfundedTxHex: t, selectedUTXOs: e, changeAddress: s, changeAmount: a, network: o } = n, { version: u, locktime: i, outputs: r } = st(t), c = new $.Transaction();
+  c.version = u, c.locktime = i;
+  for (const l of e) {
+    const d = p.from(l.txid, "hex").reverse();
+    c.addInput(d, l.vout);
+  }
+  for (const l of r)
+    c.addOutput(l.script, l.value);
+  if (a > H) {
+    const l = $.address.toOutputScript(s, o);
+    c.addOutput(l, Number(a));
+  }
+  return c.toHex();
+}
+function R(n) {
+  const t = n.startsWith("0x") ? n.slice(2) : n;
+  return `0x${E.fromHex(t).getId()}`;
+}
+function Pt(n, t, e) {
+  if (n.length === 0)
+    throw new Error("No input UTXOs provided for split transaction");
+  if (t.length === 0)
+    throw new Error("No outputs specified for split transaction");
+  for (const r of t)
+    if (r.amount <= 0n)
+      throw new Error(
+        `Invalid output amount for ${r.address}: ${r.amount} satoshis. Amount must be greater than zero.`
+      );
+  const s = C(e), a = new E();
+  a.version = 2;
+  for (const r of n) {
+    const c = p.from(r.txid, "hex").reverse();
+    a.addInput(c, r.vout);
+  }
+  const o = [];
+  for (let r = 0; r < t.length; r++) {
+    const c = t[r];
+    let l;
+    try {
+      l = q.toOutputScript(c.address, s);
+    } catch (d) {
+      throw new Error(
+        `Failed to decode address "${c.address}": ${d instanceof Error ? d.message : String(d)}`
+      );
+    }
+    a.addOutput(l, Number(c.amount)), o.push({
+      txid: "",
+      // Will be set after txid calculation
+      vout: r,
+      value: Number(c.amount),
+      scriptPubKey: l.toString("hex")
+    });
+  }
+  const u = a.toHex(), i = a.getId();
+  for (const r of o)
+    r.txid = i;
+  return {
+    txHex: u,
+    txid: i,
+    outputs: o
+  };
+}
+function Tt(n, t, e) {
+  const s = E.fromHex(n), a = new S();
+  if (a.setVersion(s.version), a.setLocktime(s.locktime), !p.isBuffer(e) || e.length !== 32)
+    throw new Error(
+      `Invalid publicKeyNoCoord: expected 32-byte Buffer (x-only pubkey), got ${p.isBuffer(e) ? `${e.length}-byte Buffer` : typeof e}`
+    );
+  if (t.length !== s.ins.length)
+    throw new Error(
+      `UTXO count mismatch: transaction has ${s.ins.length} input${s.ins.length !== 1 ? "s" : ""}, but ${t.length} UTXO${t.length !== 1 ? "s were" : " was"} provided`
+    );
+  for (let o = 0; o < s.ins.length; o++) {
+    const u = s.ins[o], i = t[o];
+    if (!i)
+      throw new Error(`Missing UTXO data for input ${o}`);
+    const r = p.from(u.hash).reverse().toString("hex"), c = u.index;
+    if (i.txid !== r || i.vout !== c)
+      throw new Error(
+        `Input ${o} outpoint mismatch: transaction expects ${r}:${c}, but UTXO ${i.txid}:${i.vout} was provided. Ensure inputs array matches the order used in createSplitTransaction().`
+      );
+    const l = p.from(i.scriptPubKey, "hex");
+    if (!(l.length === 34 && l[0] === 81 && // OP_1 (witness version 1)
+    l[1] === 32))
+      throw new Error(
+        `Input ${o} must be P2TR (Taproot). createSplitTransactionPsbt() requires P2TR inputs because it uses tapInternalKey for Taproot signing. ScriptPubKey: ${i.scriptPubKey.substring(0, 20)}...`
+      );
+    const f = {
+      script: p.from(i.scriptPubKey, "hex"),
+      value: i.value
+    };
+    a.addInput({
+      hash: u.hash,
+      index: u.index,
+      sequence: u.sequence,
+      witnessUtxo: f,
+      tapInternalKey: e
+    });
+  }
+  for (const o of s.outs)
+    a.addOutput({
+      script: o.script,
+      value: o.value
+    });
+  return a.toHex();
+}
+var v = /* @__PURE__ */ ((n) => (n.P2PKH = "P2PKH", n.P2SH = "P2SH", n.P2WPKH = "P2WPKH", n.P2WSH = "P2WSH", n.P2TR = "P2TR", n.UNKNOWN = "UNKNOWN", n))(v || {});
+function ot(n) {
+  const t = n.length;
+  return t === 25 && n[0] === 118 && // OP_DUP
+  n[1] === 169 && // OP_HASH160
+  n[2] === 20 && // Push 20 bytes
+  n[23] === 136 && // OP_EQUALVERIFY
+  n[24] === 172 ? "P2PKH" : t === 23 && n[0] === 169 && // OP_HASH160
+  n[1] === 20 && // Push 20 bytes
+  n[22] === 135 ? "P2SH" : t === 22 && n[0] === 0 && // OP_0
+  n[1] === 20 ? "P2WPKH" : t === 34 && n[0] === 0 && // OP_0
+  n[1] === 32 ? "P2WSH" : t === 34 && n[0] === 81 && // OP_1
+  n[1] === 32 ? "P2TR" : "UNKNOWN";
+}
+function at(n, t) {
+  const e = p.from(n.scriptPubKey, "hex"), s = ot(e);
+  switch (s) {
+    case v.P2WPKH:
+      return {
+        witnessUtxo: {
+          script: e,
+          value: n.value
+        }
+      };
+    case v.P2WSH: {
+      if (!n.witnessScript)
+        throw new Error("Missing witnessScript for P2WSH input");
+      return {
+        witnessUtxo: {
+          script: e,
+          value: n.value
+        },
+        witnessScript: p.from(n.witnessScript, "hex")
+      };
+    }
+    case v.P2TR: {
+      if (t && t.length !== 32)
+        throw new Error(
+          `Invalid tapInternalKey length: expected 32 bytes, got ${t.length}`
+        );
+      return {
+        witnessUtxo: {
+          script: e,
+          value: n.value
+        },
+        // tapInternalKey is needed for Taproot signing
+        ...t && { tapInternalKey: t }
+      };
+    }
+    default:
+      throw new Error(`Unsupported script type: ${s}`);
+  }
+}
+const it = {
+  mainnet: "https://mempool.space/api",
+  testnet: "https://mempool.space/testnet/api",
+  signet: "https://mempool.space/signet/api"
+};
+async function k(n, t) {
+  try {
+    const e = await fetch(n, t);
+    if (!e.ok) {
+      const a = await e.text();
+      throw new Error(
+        `Mempool API error (${e.status}): ${a || e.statusText}`
+      );
+    }
+    const s = e.headers.get("content-type");
+    return s != null && s.includes("application/json") ? await e.json() : await e.text();
+  } catch (e) {
+    throw e instanceof Error ? new Error(`Failed to fetch from mempool API: ${e.message}`) : new Error("Failed to fetch from mempool API: Unknown error");
+  }
+}
+async function ct(n, t) {
+  try {
+    const e = await fetch(`${t}/tx`, {
+      method: "POST",
+      body: n,
+      headers: {
+        "Content-Type": "text/plain"
+      }
+    });
+    if (!e.ok) {
+      const a = await e.text();
+      let o;
+      try {
+        o = JSON.parse(a).message;
+      } catch {
+        o = a;
+      }
+      throw new Error(
+        o || `Failed to broadcast transaction: ${e.statusText}`
+      );
+    }
+    return await e.text();
+  } catch (e) {
+    throw e instanceof Error ? new Error(`Failed to broadcast BTC transaction: ${e.message}`) : new Error("Failed to broadcast BTC transaction: Unknown error");
+  }
+}
+async function ut(n, t) {
+  return k(`${t}/tx/${n}`);
+}
+async function vt(n, t) {
+  try {
+    const e = await fetch(`${t}/tx/${n}/hex`);
+    if (!e.ok) {
+      const s = await e.text();
+      throw new Error(
+        `Mempool API error (${e.status}): ${s || e.statusText}`
+      );
+    }
+    return await e.text();
+  } catch (e) {
+    throw e instanceof Error ? new Error(`Failed to get transaction hex for ${n}: ${e.message}`) : new Error(`Failed to get transaction hex for ${n}: Unknown error`);
+  }
+}
+async function lt(n, t, e) {
+  const s = await ut(n, e);
+  if (t >= s.vout.length)
+    throw new Error(
+      `Invalid vout ${t} for transaction ${n} (has ${s.vout.length} outputs)`
+    );
+  const a = s.vout[t];
+  return {
+    txid: n,
+    vout: t,
+    value: a.value,
+    scriptPubKey: a.scriptpubkey
+  };
+}
+async function kt(n, t) {
+  try {
+    const e = await k(`${t}/address/${n}/utxo`), s = await k(`${t}/v1/validate-address/${n}`);
+    if (!s.isvalid)
+      throw new Error(
+        `Invalid Bitcoin address: ${n}. Mempool API validation failed.`
+      );
+    return e.sort((o, u) => u.value - o.value).map((o) => ({
+      txid: o.txid,
+      vout: o.vout,
+      value: o.value,
+      scriptPubKey: s.scriptPubKey,
+      confirmed: o.status.confirmed
+    }));
+  } catch (e) {
+    throw e instanceof Error ? new Error(
+      `Failed to get UTXOs for address ${n}: ${e.message}`
+    ) : new Error(
+      `Failed to get UTXOs for address ${n}: Unknown error`
+    );
+  }
+}
+function Et(n) {
+  return it[n];
+}
+async function It(n, t) {
+  return k(`${t}/address/${n}/txs`);
+}
+async function Bt(n) {
+  const t = await fetch(`${n}/v1/fees/recommended`);
+  if (!t.ok)
+    throw new Error(
+      `Failed to fetch network fees: ${t.status} ${t.statusText}`
+    );
+  const e = await t.json();
+  if (typeof e.fastestFee != "number" || typeof e.halfHourFee != "number" || typeof e.hourFee != "number" || typeof e.economyFee != "number" || typeof e.minimumFee != "number")
+    throw new Error(
+      "Invalid fee data structure from mempool API. Expected all fee fields to be numbers."
+    );
+  return e;
+}
+const B = [
+  {
+    type: "function",
+    name: "submitPeginRequest",
+    inputs: [
+      {
+        name: "depositor",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "depositorBtcPubKey",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "btcPopSignature",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "unsignedPegInTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "depositorPayoutBtcAddress",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorLamportPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "submitPeginRequest",
+    inputs: [
+      {
+        name: "depositor",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "depositorBtcPubKey",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "btcPopSignature",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "unsignedPegInTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "referralCode",
+        type: "uint32",
+        internalType: "uint32"
+      },
+      {
+        name: "depositorPayoutBtcAddress",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorLamportPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "getPegInFee",
+    inputs: [
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "totalFee",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getBTCVault",
+    inputs: [
+      {
+        name: "vaultId",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "vault",
+        type: "tuple",
+        internalType: "struct IBTCVaultsManager.BTCVault",
+        components: [
+          { name: "depositor", type: "address", internalType: "address" },
+          { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
+          { name: "unsignedPegInTx", type: "bytes", internalType: "bytes" },
+          { name: "amount", type: "uint256", internalType: "uint256" },
+          { name: "vaultProvider", type: "address", internalType: "address" },
+          { name: "status", type: "uint8", internalType: "enum IBTCVaultsManager.BTCVaultStatus" },
+          { name: "applicationController", type: "address", internalType: "address" },
+          { name: "universalChallengersVersion", type: "uint16", internalType: "uint16" },
+          { name: "appVaultKeepersVersion", type: "uint16", internalType: "uint16" },
+          { name: "offchainParamsVersion", type: "uint16", internalType: "uint16" },
+          { name: "createdAt", type: "uint256", internalType: "uint256" },
+          { name: "verifiedAt", type: "uint256", internalType: "uint256" },
+          { name: "depositorLamportPkHash", type: "bytes32", internalType: "bytes32" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "error",
+    name: "InvalidPeginFee",
+    inputs: [
+      {
+        name: "provided",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "required",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ]
+  }
+], x = {
+  // VaultAlreadyExists()
+  "0x04aabf33": "Vault already exists: This Bitcoin transaction has already been registered. Please select different UTXOs or use a different amount to create a unique transaction.",
+  // ScriptPubKeyMismatch() - taproot output doesn't match expected script
+  "0x4fec082d": "Script mismatch: The Bitcoin transaction's taproot output does not match the expected vault script. This may be caused by incorrect vault participants or key configuration.",
+  // InvalidBTCProofOfPossession()
+  "0x6cc363a5": "Invalid BTC proof of possession: The signature could not be verified. Please ensure you're signing with the correct Bitcoin wallet.",
+  // InvalidBTCPublicKey()
+  "0x6c3f2bf6": "Invalid BTC public key: The Bitcoin public key format is invalid.",
+  // InvalidAmount()
+  "0x2c5211c6": "Invalid amount: The deposit amount is invalid or below the minimum required.",
+  // ApplicationNotRegistered()
+  "0x0405f772": "Application not registered: The application controller is not registered in the system.",
+  // InvalidProviderStatus()
+  "0x24e165cc": "Invalid provider status: The vault provider is not in a valid state to accept deposits.",
+  // ZeroAddress()
+  "0xd92e233d": "Zero address: One of the required addresses is the zero address.",
+  // BtcKeyMismatch()
+  "0x65aa7007": "BTC key mismatch: The Bitcoin public key does not match the expected key.",
+  // Unauthorized()
+  "0x82b42900": "Unauthorized: You must be the depositor or vault provider to submit this transaction.",
+  // InvalidSignature() - common signature verification error
+  "0x8baa579f": "Invalid signature: The BTC proof of possession signature could not be verified.",
+  // InvalidBtcTransaction()
+  "0x2f9d01e9": "Invalid BTC transaction: The Bitcoin transaction format is invalid.",
+  // VaultProviderNotRegistered()
+  "0x5a3c6b3e": "Vault provider not registered: The selected vault provider is not registered.",
+  // InvalidPeginFee(uint256,uint256)
+  "0x979f4518": "Invalid pegin fee: The ETH fee sent does not match the required amount. This may indicate a fee rate change during the transaction."
+};
+function U(n) {
+  if (!n || typeof n != "object") return;
+  const t = n;
+  if (typeof t.data == "string" && t.data.startsWith("0x"))
+    return t.data;
+  if (typeof t.details == "string" && t.details.startsWith("0x"))
+    return t.details;
+  let e = t.cause, s = 0;
+  const a = 5;
+  for (; e && typeof e == "object" && s < a; ) {
+    const i = e;
+    if (typeof i.data == "string" && i.data.startsWith("0x"))
+      return i.data;
+    e = i.cause, s++;
+  }
+  const u = (typeof t.message == "string" ? t.message : "").match(/\b(0x[a-fA-F0-9]{8})\b/);
+  if (u)
+    return u[1];
+}
+function $t(n) {
+  const t = U(n);
+  if (t) {
+    const e = t.substring(0, 10);
+    return x[t] ?? x[e];
+  }
+}
+function St(n) {
+  const t = U(n);
+  if (t === void 0) return !1;
+  const e = t.substring(0, 10);
+  return t in x || e in x;
+}
+function K(n) {
+  console.error("[Contract Error] Raw error:", n);
+  const t = U(n);
+  if (console.error("[Contract Error] Extracted error data:", t), t) {
+    const s = t.substring(0, 10), a = x[t] ?? x[s];
+    if (a)
+      throw console.error("[Contract Error] Known error:", a), new Error(a);
+  }
+  const e = (n == null ? void 0 : n.message) || "";
+  if (e.includes("gas limit too high") || e.includes("21000000") || e.includes("Internal JSON-RPC error")) {
+    const s = t ? ` (error code: ${t})` : "";
+    throw console.error(
+      "[Contract Error] Transaction rejected. Error code:",
+      t,
+      "Message:",
+      e
+    ), new Error(
+      `Transaction failed: The contract rejected this transaction${s}. Possible causes: (1) Vault already exists for this transaction, (2) Invalid signature, (3) Unauthorized caller. Please check your transaction parameters and try again.`
+    );
+  }
+  throw n instanceof Error ? (console.error("[Contract Error] Unhandled error:", n.message), n) : new Error(`Contract call failed: ${String(n)}`);
+}
+class Ct {
+  /**
+   * Creates a new PeginManager instance.
+   *
+   * @param config - Manager configuration including wallets and contract addresses
+   */
+  constructor(t) {
+    I(this, "config");
+    this.config = t;
+  }
+  /**
+   * Prepares a peg-in transaction by building and funding it.
+   *
+   * This method orchestrates the following steps:
+   * 1. Get depositor BTC public key from wallet
+   * 2. Build unfunded PSBT using primitives
+   * 3. Select UTXOs using iterative fee calculation
+   * 4. Fund transaction by adding inputs and change output
+   *
+   * The returned transaction is funded but unsigned. Use `signAndBroadcast()`
+   * to complete the Bitcoin side, and `registerPeginOnChain()` for Ethereum.
+   *
+   * @param params - Peg-in parameters including amount, provider, UTXOs, and fee rate
+   * @returns Peg-in result with funded transaction and selection details
+   * @throws Error if wallet operations fail or insufficient funds
+   */
+  async preparePegin(t) {
+    const e = await this.config.btcWallet.getPublicKeyHex(), s = e.length === 66 ? e.slice(2) : e, a = T(t.vaultProviderBtcPubkey), o = t.vaultKeeperBtcPubkeys.map(T), u = t.universalChallengerBtcPubkeys.map(T), i = await z({
+      depositorPubkey: s,
+      vaultProviderPubkey: a,
+      vaultKeeperPubkeys: o,
+      universalChallengerPubkeys: u,
+      timelockPegin: t.timelockPegin,
+      pegInAmount: t.amount,
+      depositorClaimValue: t.depositorClaimValue,
+      network: this.config.btcNetwork
+    }), r = t.amount + t.depositorClaimValue, c = nt(
+      t.availableUTXOs,
+      r,
+      t.feeRate
+    ), l = C(this.config.btcNetwork), d = rt({
+      unfundedTxHex: i.psbtHex,
+      selectedUTXOs: c.selectedUTXOs,
+      changeAddress: t.changeAddress,
+      changeAmount: c.changeAmount,
+      network: l
+    }), f = R(d);
+    return {
+      btcTxHash: T(f),
+      fundedTxHex: d,
+      vaultScriptPubKey: i.vaultScriptPubKey,
+      selectedUTXOs: c.selectedUTXOs,
+      fee: c.fee,
+      changeAmount: c.changeAmount,
+      ethTxHash: null
+    };
+  }
+  /**
+   * Signs and broadcasts a funded peg-in transaction to the Bitcoin network.
+   *
+   * This method:
+   * 1. Parses the funded transaction hex
+   * 2. Fetches UTXO data from mempool for each input
+   * 3. Creates a PSBT with proper witnessUtxo/tapInternalKey
+   * 4. Signs via btcWallet.signPsbt()
+   * 5. Finalizes and extracts the transaction
+   * 6. Broadcasts via mempool API
+   *
+   * @param params - Transaction hex and depositor public key
+   * @returns The broadcasted Bitcoin transaction ID
+   * @throws Error if signing or broadcasting fails
+   */
+  async signAndBroadcast(t) {
+    const { fundedTxHex: e, depositorBtcPubkey: s } = t, a = e.startsWith("0x") ? e.slice(2) : e, o = E.fromHex(a);
+    if (o.ins.length === 0)
+      throw new Error("Transaction has no inputs");
+    const u = new S();
+    u.setVersion(o.version), u.setLocktime(o.locktime);
+    const i = s.startsWith("0x") ? s.slice(2) : s;
+    if (i.length !== 64 || !/^[0-9a-fA-F]+$/.test(i))
+      throw new Error(
+        "Invalid depositorBtcPubkey: expected 64 hex characters (x-only pubkey)"
+      );
+    const r = p.from(i, "hex");
+    if (r.length !== 32)
+      throw new Error(
+        `Invalid depositorBtcPubkey length: expected 32 bytes, got ${r.length}`
+      );
+    const c = this.config.mempoolApiUrl, l = o.ins.map((h) => {
+      const y = p.from(h.hash).reverse().toString("hex"), m = h.index;
+      return lt(y, m, c).then((P) => ({
+        input: h,
+        utxoData: P,
+        txid: y,
+        vout: m
+      }));
+    }), d = await Promise.all(l);
+    for (const { input: h, utxoData: y, txid: m, vout: P } of d) {
+      const w = at(
+        {
+          value: y.value,
+          scriptPubKey: y.scriptPubKey
+        },
+        r
+      );
+      u.addInput({
+        hash: h.hash,
+        index: h.index,
+        sequence: h.sequence,
+        ...w
+      });
+    }
+    for (const h of o.outs)
+      u.addOutput({
+        script: h.script,
+        value: h.value
+      });
+    const f = await this.config.btcWallet.signPsbt(u.toHex()), g = S.fromHex(f);
+    try {
+      g.finalizeAllInputs();
+    } catch {
+    }
+    const b = g.extractTransaction().toHex();
+    return await ct(b, c);
+  }
+  /**
+   * Registers a peg-in on Ethereum by calling the BTCVaultsManager contract.
+   *
+   * This method:
+   * 1. Gets depositor ETH address from wallet
+   * 2. Creates proof of possession (BTC signature of ETH address)
+   * 3. Checks if vault already exists (pre-flight check)
+   * 4. Encodes the contract call using viem
+   * 5. Estimates gas (catches contract errors early with proper revert reasons)
+   * 6. Sends transaction with pre-estimated gas via ethWallet.sendTransaction()
+   *
+   * @param params - Registration parameters including BTC pubkey and unsigned tx
+   * @returns Result containing Ethereum transaction hash and vault ID
+   * @throws Error if signing or transaction fails
+   * @throws Error if vault already exists
+   * @throws Error if contract simulation fails (e.g., invalid signature, unauthorized)
+   */
+  async registerPeginOnChain(t) {
+    const {
+      depositorBtcPubkey: e,
+      unsignedBtcTx: s,
+      vaultProvider: a,
+      onPopSigned: o,
+      depositorPayoutBtcAddress: u,
+      depositorLamportPkHash: i,
+      preSignedBtcPopSignature: r
+    } = t;
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const c = this.config.ethWallet.account.address, l = await this.resolvePopSignature(
+      c,
+      r
+    );
+    o && await o();
+    const d = e.startsWith("0x") ? e : `0x${e}`, f = s.startsWith("0x") ? s : `0x${s}`, g = await this.resolvePayoutScriptPubKey(
+      u
+    ), b = R(f);
+    if (await this.checkVaultExists(b))
+      throw new Error(
+        `Vault already exists for this transaction (ID: ${b}). Vault IDs are deterministically derived from the unsigned Bitcoin transaction, so using the same UTXOs and amount will always produce the same vault. To create a new vault, please use different UTXOs or a different amount to generate a unique transaction.`
+      );
+    const h = F({
+      chain: this.config.ethChain,
+      transport: M()
+    });
+    let y;
+    try {
+      y = await h.readContract({
+        address: this.config.vaultContracts.btcVaultsManager,
+        abi: B,
+        functionName: "getPegInFee",
+        args: [a]
+      });
+    } catch {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct."
+      );
+    }
+    const m = Y({
+      abi: B,
+      functionName: "submitPeginRequest",
+      args: [
+        c,
+        d,
+        l,
+        f,
+        a,
+        g,
+        i
+      ]
+    });
+    let P;
+    try {
+      P = await h.estimateGas({
+        to: this.config.vaultContracts.btcVaultsManager,
+        data: m,
+        value: y,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (w) {
+      K(w);
+    }
+    try {
+      return {
+        ethTxHash: await this.config.ethWallet.sendTransaction({
+          to: this.config.vaultContracts.btcVaultsManager,
+          data: m,
+          value: y,
+          account: this.config.ethWallet.account,
+          chain: this.config.ethChain,
+          gas: P
+        }),
+        vaultId: b,
+        btcPopSignature: l
+      };
+    } catch (w) {
+      K(w);
+    }
+  }
+  /**
+   * Check if a vault already exists for a given vault ID.
+   *
+   * @param vaultId - The Bitcoin transaction hash (vault ID)
+   * @returns True if vault exists, false otherwise
+   */
+  async checkVaultExists(t) {
+    try {
+      return (await F({
+        chain: this.config.ethChain,
+        transport: M()
+      }).readContract({
+        address: this.config.vaultContracts.btcVaultsManager,
+        abi: B,
+        functionName: "getBTCVault",
+        args: [t]
+      })).depositor !== J;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Resolve the BTC payout address to a scriptPubKey hex for the contract.
+   *
+   * If a payout address is provided, converts it directly.
+   * If omitted, uses the wallet's address and validates it against the
+   * wallet's public key to guard against a compromised wallet provider.
+   */
+  async resolvePayoutScriptPubKey(t) {
+    let e;
+    if (t)
+      e = t;
+    else {
+      e = await this.config.btcWallet.getAddress();
+      const a = await this.config.btcWallet.getPublicKeyHex();
+      if (!j(
+        e,
+        a,
+        this.config.btcNetwork
+      ))
+        throw new Error(
+          "The BTC address from your wallet does not match the wallet's public key. Please ensure your wallet is using a supported address type (Taproot or Native SegWit)."
+        );
+    }
+    const s = C(this.config.btcNetwork);
+    try {
+      return `0x${$.address.toOutputScript(e, s).toString("hex")}`;
+    } catch {
+      throw new Error(
+        `Invalid BTC payout address: "${e}". Please provide a valid Bitcoin address for the ${this.config.btcNetwork} network.`
+      );
+    }
+  }
+  /**
+   * Resolve or create a BTC Proof-of-Possession signature.
+   *
+   * Reuses a pre-signed signature when provided (e.g. multi-vault deposits),
+   * otherwise signs a BIP-322 message with the BTC wallet.
+   */
+  async resolvePopSignature(t, e) {
+    if (e)
+      return e;
+    const s = this.config.vaultContracts.btcVaultsManager, a = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${s.toLowerCase()}`, o = await this.config.btcWallet.signMessage(
+      a,
+      "bip322-simple"
+    );
+    return o.startsWith("0x") ? o : `0x${p.from(o, "base64").toString("hex")}`;
+  }
+  /**
+   * Gets the configured Bitcoin network.
+   *
+   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
+   */
+  getNetwork() {
+    return this.config.btcNetwork;
+  }
+  /**
+   * Gets the configured BTCVaultsManager contract address.
+   *
+   * @returns The Ethereum address of the BTCVaultsManager contract
+   */
+  getVaultContractAddress() {
+    return this.config.vaultContracts.btcVaultsManager;
+  }
+}
+class Ht {
+  /**
+   * Creates a new PayoutManager instance.
+   *
+   * @param config - Manager configuration including wallet
+   */
+  constructor(t) {
+    I(this, "config");
+    this.config = t;
+  }
+  /**
+   * Signs a Payout transaction and extracts the Schnorr signature.
+   *
+   * Flow:
+   * 1. Vault provider submits Claim transaction
+   * 2. Claimer submits Assert transaction to prove validity
+   * 3. Payout can be executed (references Assert tx)
+   *
+   * This method orchestrates the following steps:
+   * 1. Get wallet's public key and convert to x-only format
+   * 2. Validate wallet pubkey matches on-chain depositor pubkey (if provided)
+   * 3. Build unsigned PSBT using primitives
+   * 4. Sign PSBT via btcWallet.signPsbt()
+   * 5. Extract 64-byte Schnorr signature using primitives
+   *
+   * The returned signature can be submitted to the vault provider API.
+   *
+   * @param params - Payout signing parameters
+   * @returns Signature result with 64-byte Schnorr signature and depositor pubkey
+   * @throws Error if wallet pubkey doesn't match depositor pubkey
+   * @throws Error if wallet operations fail or signature extraction fails
+   */
+  async signPayoutTransaction(t) {
+    const e = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: s } = A(
+      e,
+      t.depositorBtcPubkey
+    ), a = await O({
+      payoutTxHex: t.payoutTxHex,
+      peginTxHex: t.peginTxHex,
+      assertTxHex: t.assertTxHex,
+      depositorBtcPubkey: s,
+      vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
+      vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
+      universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
+      timelockPegin: t.timelockPegin,
+      network: this.config.network
+    }), o = await this.config.btcWallet.signPsbt(
+      a.psbtHex,
+      {
+        autoFinalized: !1,
+        signInputs: [
+          {
+            index: 0,
+            publicKey: e,
+            disableTweakSigner: !0
+          }
+        ]
+      }
+    );
+    return {
+      signature: W(o, s),
+      depositorBtcPubkey: s
+    };
+  }
+  /**
+   * Gets the configured Bitcoin network.
+   *
+   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
+   */
+  getNetwork() {
+    return this.config.network;
+  }
+  /**
+   * Checks if the wallet supports batch signing (signPsbts).
+   *
+   * @returns true if batch signing is supported
+   */
+  supportsBatchSigning() {
+    return typeof this.config.btcWallet.signPsbts == "function";
+  }
+  /**
+   * Batch signs multiple payout transactions (1 per claimer).
+   * This allows signing all transactions with a single wallet interaction.
+   *
+   * @param transactions - Array of payout params to sign
+   * @returns Array of signature results matching input order
+   * @throws Error if wallet doesn't support batch signing
+   * @throws Error if any signing operation fails
+   */
+  async signPayoutTransactionsBatch(t) {
+    if (!this.supportsBatchSigning())
+      throw new Error(
+        "Wallet does not support batch signing (signPsbts method not available)"
+      );
+    const e = await this.config.btcWallet.getPublicKeyHex(), s = [], a = [], o = [];
+    for (const r of t) {
+      const { depositorPubkey: c } = A(
+        e,
+        r.depositorBtcPubkey
+      );
+      o.push(c);
+      const l = await O({
+        payoutTxHex: r.payoutTxHex,
+        peginTxHex: r.peginTxHex,
+        assertTxHex: r.assertTxHex,
+        depositorBtcPubkey: c,
+        vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
+        vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys,
+        universalChallengerBtcPubkeys: r.universalChallengerBtcPubkeys,
+        timelockPegin: r.timelockPegin,
+        network: this.config.network
+      });
+      s.push(l.psbtHex), a.push({
+        autoFinalized: !1,
+        signInputs: [
+          {
+            index: 0,
+            publicKey: e,
+            disableTweakSigner: !0
+          }
+        ]
+      });
+    }
+    const u = await this.config.btcWallet.signPsbts(
+      s,
+      a
+    );
+    if (u.length !== t.length)
+      throw new Error(
+        `Expected ${t.length} signed PSBTs but received ${u.length}`
+      );
+    const i = [];
+    for (let r = 0; r < t.length; r++) {
+      const c = o[r], l = W(
+        u[r],
+        c
+      );
+      i.push({
+        payoutSignature: l,
+        depositorBtcPubkey: c
+      });
+    }
+    return i;
+  }
+}
+export {
+  St as A,
+  N as B,
+  x as C,
+  H as D,
+  K as E,
+  mt as F,
+  Q as L,
+  V as M,
+  Z as P,
+  G as T,
+  tt as W,
+  wt as a,
+  Pt as b,
+  R as c,
+  Tt as d,
+  v as e,
+  rt as f,
+  xt as g,
+  ot as h,
+  at as i,
+  Ct as j,
+  Ht as k,
+  It as l,
+  kt as m,
+  Et as n,
+  Bt as o,
+  st as p,
+  vt as q,
+  et as r,
+  nt as s,
+  ut as t,
+  lt as u,
+  it as v,
+  ct as w,
+  B as x,
+  U as y,
+  $t as z
+};
+//# sourceMappingURL=PayoutManager-rMj54HDh.js.map