@babylonlabs-io/ts-sdk 0.8.1 → 0.10.0

package/dist/PayoutManager-6IBl1Fdt.js

@@ -1,1203 +0,0 @@
-var Z = Object.defineProperty;
-var G = (n, t, e) => t in n ? Z(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
-var S = (n, t, e) => G(n, typeof t != "symbol" ? t + "" : t, e);
-import * as Q from "bitcoinjs-lib";
-import { script as Y, Transaction as $, address as tt, Psbt as F } from "bitcoinjs-lib";
-import { Buffer as g } from "buffer";
-import { P as et, x as nt, D as q, M as R, B as rt, T as st, A as C, t as k, b as ot, z as at, a as it, d as ct, e as ut, f as lt, r as B, p as dt, w as W, g as N, h as K } from "./challengeAssert-D50t_Qyo.js";
-import { createPublicClient as M, http as X, encodeFunctionData as pt, zeroAddress as ht } from "viem";
-import { c as O } from "./signOptions-Drwr3bXB.js";
-import { SINGLE_DEPOSIT_HTLC_VOUT as D } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-function ft(n, t, e) {
-  if (n.length === 0)
-    throw new Error("Insufficient funds: no UTXOs available");
-  const r = n.filter((a) => {
-    const u = g.from(a.scriptPubKey, "hex");
-    return !!Y.decompile(u);
-  });
-  if (r.length === 0)
-    throw new Error(
-      "Insufficient funds: no valid UTXOs available (all have invalid scripts)"
-    );
-  const o = [...r].sort((a, u) => u.value - a.value), s = [];
-  let c = 0n, i = 0n;
-  for (const a of o) {
-    s.push(a), c += BigInt(a.value);
-    const u = s.length * et, l = 2 * R, p = u + l + st;
-    if (i = BigInt(Math.ceil(p * e)) + BigInt(nt(e)), c - t - i > q) {
-      const y = BigInt(
-        Math.ceil(R * e)
-      );
-      i += y;
-    }
-    if (c >= t + i) {
-      const y = c - t - i;
-      return {
-        selectedUTXOs: s,
-        totalValue: c,
-        fee: i,
-        changeAmount: y
-      };
-    }
-  }
-  throw new Error(
-    `Insufficient funds: need ${t + i} sats (${t} pegin + ${i} fee), have ${c} sats`
-  );
-}
-function Ht(n) {
-  return n > q;
-}
-function Ft() {
-  return rt;
-}
-function _(n) {
-  const t = n.startsWith("0x") ? n.slice(2) : n;
-  return `0x${$.fromHex(t).getId()}`;
-}
-function Ct(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 a of t)
-    if (a.amount <= 0n)
-      throw new Error(
-        `Invalid output amount for ${a.address}: ${a.amount} satoshis. Amount must be greater than zero.`
-      );
-  const r = C(e), o = new $();
-  o.version = 2;
-  for (const a of n) {
-    const u = g.from(a.txid, "hex").reverse();
-    o.addInput(u, a.vout);
-  }
-  const s = [];
-  for (let a = 0; a < t.length; a++) {
-    const u = t[a];
-    let l;
-    try {
-      l = tt.toOutputScript(u.address, r);
-    } catch (p) {
-      throw new Error(
-        `Failed to decode address "${u.address}": ${p instanceof Error ? p.message : String(p)}`
-      );
-    }
-    o.addOutput(l, Number(u.amount)), s.push({
-      txid: "",
-      // Will be set after txid calculation
-      vout: a,
-      value: Number(u.amount),
-      scriptPubKey: l.toString("hex")
-    });
-  }
-  const c = o.toHex(), i = o.getId();
-  for (const a of s)
-    a.txid = i;
-  return {
-    txHex: c,
-    txid: i,
-    outputs: s
-  };
-}
-function Ot(n, t, e) {
-  const r = $.fromHex(n), o = new F();
-  if (o.setVersion(r.version), o.setLocktime(r.locktime), !g.isBuffer(e) || e.length !== 32)
-    throw new Error(
-      `Invalid publicKeyNoCoord: expected 32-byte Buffer (x-only pubkey), got ${g.isBuffer(e) ? `${e.length}-byte Buffer` : typeof e}`
-    );
-  if (t.length !== r.ins.length)
-    throw new Error(
-      `UTXO count mismatch: transaction has ${r.ins.length} input${r.ins.length !== 1 ? "s" : ""}, but ${t.length} UTXO${t.length !== 1 ? "s were" : " was"} provided`
-    );
-  for (let s = 0; s < r.ins.length; s++) {
-    const c = r.ins[s], i = t[s];
-    if (!i)
-      throw new Error(`Missing UTXO data for input ${s}`);
-    const a = g.from(c.hash).reverse().toString("hex"), u = c.index;
-    if (i.txid !== a || i.vout !== u)
-      throw new Error(
-        `Input ${s} outpoint mismatch: transaction expects ${a}:${u}, but UTXO ${i.txid}:${i.vout} was provided. Ensure inputs array matches the order used in createSplitTransaction().`
-      );
-    const l = g.from(i.scriptPubKey, "hex");
-    if (!(l.length === 34 && l[0] === 81 && // OP_1 (witness version 1)
-    l[1] === 32))
-      throw new Error(
-        `Input ${s} must be P2TR (Taproot). createSplitTransactionPsbt() requires P2TR inputs because it uses tapInternalKey for Taproot signing. ScriptPubKey: ${i.scriptPubKey.substring(0, 20)}...`
-      );
-    const h = {
-      script: g.from(i.scriptPubKey, "hex"),
-      value: i.value
-    };
-    o.addInput({
-      hash: c.hash,
-      index: c.index,
-      sequence: c.sequence,
-      witnessUtxo: h,
-      tapInternalKey: e
-    });
-  }
-  for (const s of r.outs)
-    o.addOutput({
-      script: s.script,
-      value: s.value
-    });
-  return o.toHex();
-}
-var E = /* @__PURE__ */ ((n) => (n.P2PKH = "P2PKH", n.P2SH = "P2SH", n.P2WPKH = "P2WPKH", n.P2WSH = "P2WSH", n.P2TR = "P2TR", n.UNKNOWN = "UNKNOWN", n))(E || {});
-function gt(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 yt(n, t) {
-  const e = g.from(n.scriptPubKey, "hex"), r = gt(e);
-  switch (r) {
-    case E.P2WPKH:
-      return {
-        witnessUtxo: {
-          script: e,
-          value: n.value
-        }
-      };
-    case E.P2WSH: {
-      if (!n.witnessScript)
-        throw new Error("Missing witnessScript for P2WSH input");
-      return {
-        witnessUtxo: {
-          script: e,
-          value: n.value
-        },
-        witnessScript: g.from(n.witnessScript, "hex")
-      };
-    }
-    case E.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: ${r}`);
-  }
-}
-const bt = 21e6 * 1e8, L = 1e4;
-function j(n) {
-  return Number.isInteger(n) && n > 0 && n <= bt;
-}
-function mt(n) {
-  return Number.isInteger(n) && n > 0 && n <= L;
-}
-function J(n, t) {
-  return !Number.isInteger(n) || n < 0 ? !1 : t === void 0 || n < t;
-}
-const Pt = {
-  mainnet: "https://mempool.space/api",
-  testnet: "https://mempool.space/testnet/api",
-  signet: "https://mempool.space/signet/api"
-};
-async function I(n, t) {
-  try {
-    const e = await fetch(n, t);
-    if (!e.ok) {
-      const o = await e.text();
-      throw new Error(
-        `Mempool API error (${e.status}): ${o || e.statusText}`
-      );
-    }
-    const r = e.headers.get("content-type");
-    return r != null && r.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 xt(n, t) {
-  try {
-    const e = await fetch(`${t}/tx`, {
-      method: "POST",
-      body: n,
-      headers: {
-        "Content-Type": "text/plain"
-      }
-    });
-    if (!e.ok) {
-      const o = await e.text();
-      let s;
-      try {
-        s = JSON.parse(o).message;
-      } catch {
-        s = o;
-      }
-      throw new Error(
-        s || `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 wt(n, t) {
-  return I(`${t}/tx/${n}`);
-}
-async function Ut(n, t) {
-  try {
-    const e = await fetch(`${t}/tx/${n}/hex`);
-    if (!e.ok) {
-      const r = await e.text();
-      throw new Error(
-        `Mempool API error (${e.status}): ${r || 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 Tt(n, t, e) {
-  const r = await wt(n, e);
-  if (!J(t, r.vout.length))
-    throw new Error(
-      `Invalid vout ${t} for transaction ${n} (has ${r.vout.length} outputs)`
-    );
-  const o = r.vout[t];
-  if (!j(o.value))
-    throw new Error(`Invalid UTXO value ${o.value} for ${n}:${t}`);
-  return {
-    txid: n,
-    vout: t,
-    value: o.value,
-    scriptPubKey: o.scriptpubkey
-  };
-}
-async function At(n, t) {
-  try {
-    const e = await I(`${t}/address/${n}/utxo`), r = await I(`${t}/v1/validate-address/${n}`);
-    if (!r.isvalid)
-      throw new Error(
-        `Invalid Bitcoin address: ${n}. Mempool API validation failed.`
-      );
-    for (const s of e) {
-      if (!J(s.vout))
-        throw new Error(`Invalid vout ${s.vout} for ${s.txid}`);
-      if (!j(s.value))
-        throw new Error(
-          `Invalid UTXO value ${s.value} for ${s.txid}:${s.vout}`
-        );
-    }
-    return e.sort((s, c) => c.value - s.value).map((s) => ({
-      txid: s.txid,
-      vout: s.vout,
-      value: s.value,
-      scriptPubKey: r.scriptPubKey,
-      confirmed: s.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 Vt(n) {
-  return Pt[n];
-}
-async function Rt(n, t) {
-  return I(`${t}/address/${n}/txs`);
-}
-async function Wt(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(), r = [
-    "fastestFee",
-    "halfHourFee",
-    "hourFee",
-    "economyFee",
-    "minimumFee"
-  ];
-  for (const o of r)
-    if (!mt(e[o]))
-      throw new Error(
-        `Invalid fee rate ${o}=${e[o]} from mempool API: expected a positive number ≤ ${L}`
-      );
-  if (e.minimumFee > e.economyFee || e.economyFee > e.hourFee || e.hourFee > e.halfHourFee || e.halfHourFee > e.fastestFee)
-    throw new Error(
-      `Fee rate ordering violation from mempool API: expected minimumFee (${e.minimumFee}) <= economyFee (${e.economyFee}) <= hourFee (${e.hourFee}) <= halfHourFee (${e.halfHourFee}) <= fastestFee (${e.fastestFee}).`
-    );
-  return e;
-}
-const H = [
-  {
-    type: "function",
-    name: "submitPeginRequest",
-    inputs: [
-      {
-        name: "depositor",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "depositorBtcPubKey",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "btcPopSignature",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "unsignedPrePeginTx",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "depositorSignedPeginTx",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "vaultProvider",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "hashlock",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "htlcVout",
-        type: "uint8",
-        internalType: "uint8"
-      },
-      {
-        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: "unsignedPrePeginTx",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "depositorSignedPeginTx",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "vaultProvider",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "hashlock",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "htlcVout",
-        type: "uint8",
-        internalType: "uint8"
-      },
-      {
-        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: "activateVaultWithSecret",
-    inputs: [
-      {
-        name: "vaultId",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "s",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  {
-    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 IBTCVaultRegistry.BTCVault",
-        components: [
-          { name: "depositor", type: "address", internalType: "address" },
-          { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
-          { name: "depositorSignedPeginTx", type: "bytes", internalType: "bytes" },
-          { name: "amount", type: "uint256", internalType: "uint256" },
-          { name: "vaultProvider", type: "address", internalType: "address" },
-          { name: "status", type: "uint8", internalType: "enum IBTCVaultRegistry.BTCVaultStatus" },
-          { name: "applicationEntryPoint", type: "address", internalType: "address" },
-          { name: "universalChallengersVersion", type: "uint16", internalType: "uint16" },
-          { name: "appVaultKeepersVersion", type: "uint16", internalType: "uint16" },
-          { name: "offchainParamsVersion", type: "uint16", internalType: "uint16" },
-          { name: "proverProgramVersion", type: "uint16", internalType: "uint16" },
-          { name: "createdAt", type: "uint256", internalType: "uint256" },
-          { name: "verifiedAt", type: "uint256", internalType: "uint256" },
-          { name: "depositorLamportPkHash", type: "bytes32", internalType: "bytes32" },
-          { name: "hashlock", type: "bytes32", internalType: "bytes32" },
-          { name: "htlcVout", type: "uint8", internalType: "uint8" }
-        ]
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "error",
-    name: "InvalidPeginFee",
-    inputs: [
-      {
-        name: "provided",
-        type: "uint256",
-        internalType: "uint256"
-      },
-      {
-        name: "required",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ]
-  },
-  {
-    type: "error",
-    name: "InvalidSecret",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "ActivationDeadlineExpired",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "InvalidHashlock",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "DuplicateHashlock",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "CapExceeded",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "InvalidOutputIndex",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "PeginSignaturesIncomplete",
-    inputs: []
-  }
-], P = {
-  // 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, r = 0;
-  const o = 5;
-  for (; e && typeof e == "object" && r < o; ) {
-    const i = e;
-    if (typeof i.data == "string" && i.data.startsWith("0x"))
-      return i.data;
-    e = i.cause, r++;
-  }
-  const c = (typeof t.message == "string" ? t.message : "").match(/\b(0x[a-fA-F0-9]{8})\b/);
-  if (c)
-    return c[1];
-}
-function Nt(n) {
-  const t = U(n);
-  if (t) {
-    const e = t.substring(0, 10);
-    return P[t] ?? P[e];
-  }
-}
-function Kt(n) {
-  const t = U(n);
-  if (t === void 0) return !1;
-  const e = t.substring(0, 10);
-  return t in P || e in P;
-}
-function z(n) {
-  console.error("[Contract Error] Raw error:", n);
-  const t = U(n);
-  if (console.error("[Contract Error] Extracted error data:", t), t) {
-    const r = t.substring(0, 10), o = P[t] ?? P[r];
-    if (o)
-      throw console.error("[Contract Error] Known error:", o), new Error(o);
-  }
-  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 r = 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${r}. 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 Mt {
-  /**
-   * Creates a new PeginManager instance.
-   *
-   * @param config - Manager configuration including wallets and contract addresses
-   */
-  constructor(t) {
-    S(this, "config");
-    this.config = t;
-  }
-  /**
-   * Prepares a peg-in by building the Pre-PegIn HTLC transaction,
-   * funding it, constructing the PegIn transaction, and signing the PegIn input.
-   *
-   * This method orchestrates the following steps:
-   * 1. Get depositor BTC public key from wallet
-   * 2. Build unfunded Pre-PegIn transaction (HTLC output) using primitives
-   * 3. Select UTXOs to cover the HTLC value
-   * 4. Fund the Pre-PegIn transaction
-   * 5. Derive the PegIn transaction from the funded Pre-PegIn txid
-   * 6. Build PSBT for signing the PegIn input (HTLC leaf 0)
-   * 7. Sign via BTC wallet and extract depositor signature
-   *
-   * The returned `fundedPrePeginTxHex` is funded but unsigned (inputs unsigned).
-   * Use `signAndBroadcast()` AFTER registering on Ethereum to broadcast it.
-   *
-   * @param params - Pegin parameters including amount, HTLC params, UTXOs
-   * @returns Pegin result with funded Pre-PegIn tx, signed PegIn input, and signatures
-   * @throws Error if wallet operations fail or insufficient funds
-   */
-  async preparePegin(t) {
-    const e = await this.config.btcWallet.getPublicKeyHex(), r = e.length === 66 ? e.slice(2) : e, o = k(t.vaultProviderBtcPubkey), s = t.vaultKeeperBtcPubkeys.map(k), c = t.universalChallengerBtcPubkeys.map(k);
-    if (t.hashlocks.length !== 1)
-      throw new Error(
-        "hashlocks must contain exactly one entry (batched deposits not yet supported)"
-      );
-    const i = s.length, a = {
-      depositorPubkey: r,
-      vaultProviderPubkey: o,
-      vaultKeeperPubkeys: s,
-      universalChallengerPubkeys: c,
-      hashlocks: t.hashlocks,
-      timelockRefund: t.timelockRefund,
-      pegInAmount: t.amount,
-      feeRate: t.protocolFeeRate,
-      numLocalChallengers: i,
-      councilQuorum: t.councilQuorum,
-      councilSize: t.councilSize,
-      network: this.config.btcNetwork
-    }, u = await ot(a), l = ft(
-      [...t.availableUTXOs],
-      u.totalOutputValue,
-      t.mempoolFeeRate
-    ), p = C(this.config.btcNetwork), h = at({
-      unfundedTxHex: u.psbtHex,
-      selectedUTXOs: l.selectedUTXOs,
-      changeAddress: t.changeAddress,
-      changeAmount: l.changeAmount,
-      network: p
-    }), y = k(_(h)), m = await it({
-      prePeginParams: a,
-      timelockPegin: t.timelockPegin,
-      fundedPrePeginTxHex: h,
-      htlcVout: D
-    }), x = await ct({
-      peginTxHex: m.txHex,
-      fundedPrePeginTxHex: h,
-      depositorPubkey: r,
-      vaultProviderPubkey: o,
-      vaultKeeperPubkeys: s,
-      universalChallengerPubkeys: c,
-      hashlock: t.hashlocks[0],
-      timelockRefund: t.timelockRefund,
-      network: this.config.btcNetwork
-    }), d = await this.config.btcWallet.signPsbt(
-      x.psbtHex,
-      O(e, 1)
-    ), f = ut(
-      d,
-      r
-    ), b = lt(d);
-    return {
-      fundedPrePeginTxHex: h,
-      htlcValue: u.htlcValue,
-      signedPeginInputPsbtHex: d,
-      peginInputSignature: f,
-      vaultScriptPubKey: m.vaultScriptPubKey,
-      peginTxHex: b,
-      prePeginTxid: y,
-      peginTxid: m.txid,
-      selectedUTXOs: l.selectedUTXOs,
-      fee: l.fee,
-      changeAmount: l.changeAmount
-    };
-  }
-  /**
-   * 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 { fundedPrePeginTxHex: e, depositorBtcPubkey: r } = t, o = e.startsWith("0x") ? e.slice(2) : e, s = $.fromHex(o);
-    if (s.ins.length === 0)
-      throw new Error("Transaction has no inputs");
-    const c = new F();
-    c.setVersion(s.version), c.setLocktime(s.locktime);
-    const i = r.startsWith("0x") ? r.slice(2) : r;
-    if (i.length !== 64 || !/^[0-9a-fA-F]+$/.test(i))
-      throw new Error(
-        "Invalid depositorBtcPubkey: expected 64 hex characters (x-only pubkey)"
-      );
-    const a = g.from(i, "hex");
-    if (a.length !== 32)
-      throw new Error(
-        `Invalid depositorBtcPubkey length: expected 32 bytes, got ${a.length}`
-      );
-    const u = this.config.mempoolApiUrl, l = s.ins.map((d) => {
-      const f = g.from(d.hash).reverse().toString("hex"), b = d.index;
-      return Tt(f, b, u).then((w) => ({
-        input: d,
-        utxoData: w,
-        txid: f,
-        vout: b
-      }));
-    }), p = await Promise.all(l);
-    for (const { input: d, utxoData: f, txid: b, vout: w } of p) {
-      const T = yt(
-        {
-          value: f.value,
-          scriptPubKey: f.scriptPubKey
-        },
-        a
-      );
-      c.addInput({
-        hash: d.hash,
-        index: d.index,
-        sequence: d.sequence,
-        ...T
-      });
-    }
-    for (const d of s.outs)
-      c.addOutput({
-        script: d.script,
-        value: d.value
-      });
-    const h = await this.config.btcWallet.signPsbt(c.toHex()), y = F.fromHex(h);
-    try {
-      y.finalizeAllInputs();
-    } catch (d) {
-      if (!y.data.inputs.every(
-        (b) => b.finalScriptWitness || b.finalScriptSig
-      ))
-        throw new Error(
-          `PSBT finalization failed and wallet did not auto-finalize: ${d}`
-        );
-    }
-    const m = y.extractTransaction().toHex();
-    return await xt(m, u);
-  }
-  /**
-   * Registers a peg-in on Ethereum by calling the BTCVaultRegistry 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,
-      unsignedPrePeginTx: r,
-      depositorSignedPeginTx: o,
-      vaultProvider: s,
-      hashlock: c,
-      onPopSigned: i,
-      depositorPayoutBtcAddress: a,
-      depositorLamportPkHash: u,
-      preSignedBtcPopSignature: l
-    } = t;
-    if (!this.config.ethWallet.account)
-      throw new Error("Ethereum wallet account not found");
-    const p = this.config.ethWallet.account.address, h = await this.resolvePopSignature(
-      p,
-      l
-    );
-    i && await i();
-    const y = B(e), m = B(r), x = B(o), d = await this.resolvePayoutScriptPubKey(
-      a
-    ), f = _(x);
-    if (await this.checkVaultExists(f))
-      throw new Error(
-        `Vault already exists for this transaction (ID: ${f}). 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 w = M({
-      chain: this.config.ethChain,
-      transport: X()
-    });
-    let T;
-    try {
-      T = await w.readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: H,
-        functionName: "getPegInFee",
-        args: [s]
-      });
-    } 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 A = pt({
-      abi: H,
-      functionName: "submitPeginRequest",
-      args: [
-        p,
-        y,
-        h,
-        m,
-        x,
-        s,
-        c,
-        D,
-        d,
-        u
-      ]
-    });
-    let V;
-    try {
-      V = await w.estimateGas({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: A,
-        value: T,
-        account: this.config.ethWallet.account.address
-      });
-    } catch (v) {
-      z(v);
-    }
-    try {
-      return {
-        ethTxHash: await this.config.ethWallet.sendTransaction({
-          to: this.config.vaultContracts.btcVaultRegistry,
-          data: A,
-          value: T,
-          account: this.config.ethWallet.account,
-          chain: this.config.ethChain,
-          gas: V
-        }),
-        vaultId: f,
-        btcPopSignature: h
-      };
-    } catch (v) {
-      z(v);
-    }
-  }
-  /**
-   * 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 M({
-        chain: this.config.ethChain,
-        transport: X()
-      }).readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: H,
-        functionName: "getBTCVault",
-        args: [t]
-      })).depositor !== ht;
-    } 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 o = await this.config.btcWallet.getPublicKeyHex();
-      if (!dt(
-        e,
-        o,
-        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 r = C(this.config.btcNetwork);
-    try {
-      return `0x${Q.address.toOutputScript(e, r).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 r = this.config.vaultContracts.btcVaultRegistry, o = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${r.toLowerCase()}`, s = await this.config.btcWallet.signMessage(
-      o,
-      "bip322-simple"
-    );
-    return s.startsWith("0x") ? s : `0x${g.from(s, "base64").toString("hex")}`;
-  }
-  /**
-   * Gets the configured Bitcoin network.
-   *
-   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
-   */
-  getNetwork() {
-    return this.config.btcNetwork;
-  }
-  /**
-   * Gets the configured BTCVaultRegistry contract address.
-   *
-   * @returns The Ethereum address of the BTCVaultRegistry contract
-   */
-  getVaultContractAddress() {
-    return this.config.vaultContracts.btcVaultRegistry;
-  }
-}
-class Xt {
-  /**
-   * Creates a new PayoutManager instance.
-   *
-   * @param config - Manager configuration including wallet
-   */
-  constructor(t) {
-    S(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: r } = W(
-      e,
-      t.depositorBtcPubkey
-    ), o = await N({
-      payoutTxHex: t.payoutTxHex,
-      peginTxHex: t.peginTxHex,
-      assertTxHex: t.assertTxHex,
-      depositorBtcPubkey: r,
-      vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
-      vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
-      universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
-      timelockPegin: t.timelockPegin,
-      network: this.config.network
-    }), s = await this.config.btcWallet.signPsbt(
-      o.psbtHex,
-      O(e, 1)
-    );
-    return {
-      signature: K(s, r),
-      depositorBtcPubkey: r
-    };
-  }
-  /**
-   * 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(), r = [], o = [], s = [];
-    for (const a of t) {
-      const { depositorPubkey: u } = W(
-        e,
-        a.depositorBtcPubkey
-      );
-      s.push(u);
-      const l = await N({
-        payoutTxHex: a.payoutTxHex,
-        peginTxHex: a.peginTxHex,
-        assertTxHex: a.assertTxHex,
-        depositorBtcPubkey: u,
-        vaultProviderBtcPubkey: a.vaultProviderBtcPubkey,
-        vaultKeeperBtcPubkeys: a.vaultKeeperBtcPubkeys,
-        universalChallengerBtcPubkeys: a.universalChallengerBtcPubkeys,
-        timelockPegin: a.timelockPegin,
-        network: this.config.network
-      });
-      r.push(l.psbtHex), o.push(O(e, 1));
-    }
-    const c = await this.config.btcWallet.signPsbts(
-      r,
-      o
-    );
-    if (c.length !== t.length)
-      throw new Error(
-        `Expected ${t.length} signed PSBTs but received ${c.length}`
-      );
-    const i = [];
-    for (let a = 0; a < t.length; a++) {
-      const u = s[a], l = K(
-        c[a],
-        u
-      );
-      i.push({
-        payoutSignature: l,
-        depositorBtcPubkey: u
-      });
-    }
-    return i;
-  }
-}
-export {
-  E as B,
-  P as C,
-  Pt as M,
-  Mt as P,
-  Ht as a,
-  Ct as b,
-  _ as c,
-  Ot as d,
-  gt as e,
-  yt as f,
-  Ft as g,
-  Xt as h,
-  Rt as i,
-  At as j,
-  Vt as k,
-  Wt as l,
-  Ut as m,
-  wt as n,
-  Tt as o,
-  xt as p,
-  H as q,
-  U as r,
-  ft as s,
-  Nt as t,
-  Kt as u,
-  z as v
-};
-//# sourceMappingURL=PayoutManager-6IBl1Fdt.js.map