@babylonlabs-io/ts-sdk 0.2.1-rc.3 → 0.4.0

package/dist/{PayoutManager-rMj54HDh.js → PayoutManager-BK1jKgL5.js}

@@ -1,195 +1,148 @@
-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";
+var q = Object.defineProperty;
+var _ = (n, t, e) => t in n ? q(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var H = (n, t, e) => _(n, typeof t != "symbol" ? t + "" : t, e);
+import * as L from "bitcoinjs-lib";
+import { script as j, Transaction as S, address as J, Psbt as C } from "bitcoinjs-lib";
+import { Buffer as g } from "buffer";
+import { P as Z, r as G, D as z, M as W, B as Q, T as Y, y as U, s as k, b as tt, x as et, a as nt, c as st, e as rt, p as I, n as at, v as V, d as M, f as R } from "./challengeAssert-Dvcg38_y.js";
+import { createPublicClient as K, http as N, encodeFunctionData as ot, zeroAddress as it } 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) {
+function ct(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);
+  const s = n.filter((a) => {
+    const u = g.from(a.scriptPubKey, "hex");
+    return !!j.decompile(u);
   });
   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)
+  const o = [...s].sort((a, u) => u.value - a.value), r = [];
+  let c = 0n, i = 0n;
+  for (const a of o) {
+    r.push(a), c += BigInt(a.value);
+    const u = r.length * Z, l = 2 * W, d = u + l + Y;
+    if (i = BigInt(Math.ceil(d * e)) + BigInt(G(e)), c - t - i > z) {
+      const h = BigInt(
+        Math.ceil(W * e)
       );
-      i += g;
+      i += h;
     }
-    if (u >= t + i) {
-      const g = u - t - i;
+    if (c >= t + i) {
+      const h = c - t - i;
       return {
-        selectedUTXOs: o,
-        totalValue: u,
+        selectedUTXOs: r,
+        totalValue: c,
         fee: i,
-        changeAmount: g
+        changeAmount: h
       };
     }
   }
   throw new Error(
-    `Insufficient funds: need ${t + i} sats (${t} pegin + ${i} fee), have ${u} sats`
+    `Insufficient funds: need ${t + i} sats (${t} pegin + ${i} fee), have ${c} sats`
   );
 }
 function wt(n) {
-  return n > H;
+  return n > z;
 }
-function xt() {
-  return N;
+function Tt() {
+  return Q;
 }
-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) {
+function X(n) {
   const t = n.startsWith("0x") ? n.slice(2) : n;
-  return `0x${E.fromHex(t).getId()}`;
+  return `0x${S.fromHex(t).getId()}`;
 }
-function Pt(n, t, e) {
+function vt(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)
+  for (const a of t)
+    if (a.amount <= 0n)
       throw new Error(
-        `Invalid output amount for ${r.address}: ${r.amount} satoshis. Amount must be greater than zero.`
+        `Invalid output amount for ${a.address}: ${a.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 s = U(e), o = new S();
+  o.version = 2;
+  for (const a of n) {
+    const u = g.from(a.txid, "hex").reverse();
+    o.addInput(u, a.vout);
   }
-  const o = [];
-  for (let r = 0; r < t.length; r++) {
-    const c = t[r];
+  const r = [];
+  for (let a = 0; a < t.length; a++) {
+    const u = t[a];
     let l;
     try {
-      l = q.toOutputScript(c.address, s);
+      l = J.toOutputScript(u.address, s);
     } catch (d) {
       throw new Error(
-        `Failed to decode address "${c.address}": ${d instanceof Error ? d.message : String(d)}`
+        `Failed to decode address "${u.address}": ${d instanceof Error ? d.message : String(d)}`
       );
     }
-    a.addOutput(l, Number(c.amount)), o.push({
+    o.addOutput(l, Number(u.amount)), r.push({
       txid: "",
       // Will be set after txid calculation
-      vout: r,
-      value: Number(c.amount),
+      vout: a,
+      value: Number(u.amount),
       scriptPubKey: l.toString("hex")
     });
   }
-  const u = a.toHex(), i = a.getId();
-  for (const r of o)
-    r.txid = i;
+  const c = o.toHex(), i = o.getId();
+  for (const a of r)
+    a.txid = i;
   return {
-    txHex: u,
+    txHex: c,
     txid: i,
-    outputs: o
+    outputs: r
   };
 }
-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)
+function kt(n, t, e) {
+  const s = S.fromHex(n), o = new C();
+  if (o.setVersion(s.version), o.setLocktime(s.locktime), !g.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}`
+      `Invalid publicKeyNoCoord: expected 32-byte Buffer (x-only pubkey), got ${g.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];
+  for (let r = 0; r < s.ins.length; r++) {
+    const c = s.ins[r], i = t[r];
     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(`Missing UTXO data for input ${r}`);
+    const a = g.from(c.hash).reverse().toString("hex"), u = c.index;
+    if (i.txid !== a || i.vout !== u)
       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().`
+        `Input ${r} 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 = p.from(i.scriptPubKey, "hex");
+    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 ${o} must be P2TR (Taproot). createSplitTransactionPsbt() requires P2TR inputs because it uses tapInternalKey for Taproot signing. ScriptPubKey: ${i.scriptPubKey.substring(0, 20)}...`
+        `Input ${r} 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"),
+      script: g.from(i.scriptPubKey, "hex"),
       value: i.value
     };
-    a.addInput({
-      hash: u.hash,
-      index: u.index,
-      sequence: u.sequence,
+    o.addInput({
+      hash: c.hash,
+      index: c.index,
+      sequence: c.sequence,
       witnessUtxo: f,
       tapInternalKey: e
     });
   }
-  for (const o of s.outs)
-    a.addOutput({
-      script: o.script,
-      value: o.value
+  for (const r of s.outs)
+    o.addOutput({
+      script: r.script,
+      value: r.value
     });
-  return a.toHex();
+  return o.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) {
+var B = /* @__PURE__ */ ((n) => (n.P2PKH = "P2PKH", n.P2SH = "P2SH", n.P2WPKH = "P2WPKH", n.P2WSH = "P2WSH", n.P2TR = "P2TR", n.UNKNOWN = "UNKNOWN", n))(B || {});
+function ut(n) {
   const t = n.length;
   return t === 25 && n[0] === 118 && // OP_DUP
   n[1] === 169 && // OP_HASH160
@@ -202,17 +155,17 @@ function ot(n) {
   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);
+function lt(n, t) {
+  const e = g.from(n.scriptPubKey, "hex"), s = ut(e);
   switch (s) {
-    case v.P2WPKH:
+    case B.P2WPKH:
       return {
         witnessUtxo: {
           script: e,
           value: n.value
         }
       };
-    case v.P2WSH: {
+    case B.P2WSH: {
       if (!n.witnessScript)
         throw new Error("Missing witnessScript for P2WSH input");
       return {
@@ -220,10 +173,10 @@ function at(n, t) {
           script: e,
           value: n.value
         },
-        witnessScript: p.from(n.witnessScript, "hex")
+        witnessScript: g.from(n.witnessScript, "hex")
       };
     }
-    case v.P2TR: {
+    case B.P2TR: {
       if (t && t.length !== 32)
         throw new Error(
           `Invalid tapInternalKey length: expected 32 bytes, got ${t.length}`
@@ -241,18 +194,18 @@ function at(n, t) {
       throw new Error(`Unsupported script type: ${s}`);
   }
 }
-const it = {
+const dt = {
   mainnet: "https://mempool.space/api",
   testnet: "https://mempool.space/testnet/api",
   signet: "https://mempool.space/signet/api"
 };
-async function k(n, t) {
+async function E(n, t) {
   try {
     const e = await fetch(n, t);
     if (!e.ok) {
-      const a = await e.text();
+      const o = await e.text();
       throw new Error(
-        `Mempool API error (${e.status}): ${a || e.statusText}`
+        `Mempool API error (${e.status}): ${o || e.statusText}`
       );
     }
     const s = e.headers.get("content-type");
@@ -261,7 +214,7 @@ async function k(n, t) {
     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) {
+async function pt(n, t) {
   try {
     const e = await fetch(`${t}/tx`, {
       method: "POST",
@@ -271,15 +224,15 @@ async function ct(n, t) {
       }
     });
     if (!e.ok) {
-      const a = await e.text();
-      let o;
+      const o = await e.text();
+      let r;
       try {
-        o = JSON.parse(a).message;
+        r = JSON.parse(o).message;
       } catch {
-        o = a;
+        r = o;
       }
       throw new Error(
-        o || `Failed to broadcast transaction: ${e.statusText}`
+        r || `Failed to broadcast transaction: ${e.statusText}`
       );
     }
     return await e.text();
@@ -287,10 +240,10 @@ async function ct(n, t) {
     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 ht(n, t) {
+  return E(`${t}/tx/${n}`);
 }
-async function vt(n, t) {
+async function Bt(n, t) {
   try {
     const e = await fetch(`${t}/tx/${n}/hex`);
     if (!e.ok) {
@@ -304,33 +257,33 @@ async function vt(n, t) {
     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);
+async function gt(n, t, e) {
+  const s = await ht(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];
+  const o = s.vout[t];
   return {
     txid: n,
     vout: t,
-    value: a.value,
-    scriptPubKey: a.scriptpubkey
+    value: o.value,
+    scriptPubKey: o.scriptpubkey
   };
 }
-async function kt(n, t) {
+async function Et(n, t) {
   try {
-    const e = await k(`${t}/address/${n}/utxo`), s = await k(`${t}/v1/validate-address/${n}`);
+    const e = await E(`${t}/address/${n}/utxo`), s = await E(`${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,
+    return e.sort((r, c) => c.value - r.value).map((r) => ({
+      txid: r.txid,
+      vout: r.vout,
+      value: r.value,
       scriptPubKey: s.scriptPubKey,
-      confirmed: o.status.confirmed
+      confirmed: r.status.confirmed
     }));
   } catch (e) {
     throw e instanceof Error ? new Error(
@@ -340,13 +293,13 @@ async function kt(n, t) {
     );
   }
 }
-function Et(n) {
-  return it[n];
+function St(n) {
+  return dt[n];
 }
-async function It(n, t) {
-  return k(`${t}/address/${n}/txs`);
+async function Ht(n, t) {
+  return E(`${t}/address/${n}/txs`);
 }
-async function Bt(n) {
+async function It(n) {
   const t = await fetch(`${n}/v1/fees/recommended`);
   if (!t.ok)
     throw new Error(
@@ -359,7 +312,7 @@ async function Bt(n) {
     );
   return e;
 }
-const B = [
+const $ = [
   {
     type: "function",
     name: "submitPeginRequest",
@@ -380,7 +333,12 @@ const B = [
         internalType: "bytes"
       },
       {
-        name: "unsignedPegInTx",
+        name: "unsignedPrePeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorSignedPeginTx",
         type: "bytes",
         internalType: "bytes"
       },
@@ -389,6 +347,11 @@ const B = [
         type: "address",
         internalType: "address"
       },
+      {
+        name: "hashlock",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
       {
         name: "depositorPayoutBtcAddress",
         type: "bytes",
@@ -429,7 +392,12 @@ const B = [
         internalType: "bytes"
       },
       {
-        name: "unsignedPegInTx",
+        name: "unsignedPrePeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorSignedPeginTx",
         type: "bytes",
         internalType: "bytes"
       },
@@ -438,6 +406,11 @@ const B = [
         type: "address",
         internalType: "address"
       },
+      {
+        name: "hashlock",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
       {
         name: "referralCode",
         type: "uint32",
@@ -463,6 +436,24 @@ const B = [
     ],
     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",
@@ -500,7 +491,7 @@ const B = [
         components: [
           { name: "depositor", type: "address", internalType: "address" },
           { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
-          { name: "unsignedPegInTx", type: "bytes", internalType: "bytes" },
+          { name: "depositorSignedPeginTx", type: "bytes", internalType: "bytes" },
           { name: "amount", type: "uint256", internalType: "uint256" },
           { name: "vaultProvider", type: "address", internalType: "address" },
           { name: "status", type: "uint8", internalType: "enum IBTCVaultsManager.BTCVaultStatus" },
@@ -508,9 +499,11 @@ const B = [
           { name: "universalChallengersVersion", type: "uint16", internalType: "uint16" },
           { name: "appVaultKeepersVersion", type: "uint16", internalType: "uint16" },
           { name: "offchainParamsVersion", type: "uint16", internalType: "uint16" },
+          { name: "vkVersion", type: "uint16", internalType: "uint16" },
           { name: "createdAt", type: "uint256", internalType: "uint256" },
           { name: "verifiedAt", type: "uint256", internalType: "uint256" },
-          { name: "depositorLamportPkHash", type: "bytes32", internalType: "bytes32" }
+          { name: "depositorLamportPkHash", type: "bytes32", internalType: "bytes32" },
+          { name: "hashlock", type: "bytes32", internalType: "bytes32" }
         ]
       }
     ],
@@ -531,6 +524,16 @@ const B = [
         internalType: "uint256"
       }
     ]
+  },
+  {
+    type: "error",
+    name: "InvalidSecret",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "ActivationDeadlineExpired",
+    inputs: []
   }
 ], x = {
   // VaultAlreadyExists()
@@ -562,7 +565,7 @@ const B = [
   // 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) {
+function O(n) {
   if (!n || typeof n != "object") return;
   const t = n;
   if (typeof t.data == "string" && t.data.startsWith("0x"))
@@ -570,37 +573,37 @@ function U(n) {
   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 o = 5;
+  for (; e && typeof e == "object" && s < o; ) {
     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];
+  const c = (typeof t.message == "string" ? t.message : "").match(/\b(0x[a-fA-F0-9]{8})\b/);
+  if (c)
+    return c[1];
 }
 function $t(n) {
-  const t = U(n);
+  const t = O(n);
   if (t) {
     const e = t.substring(0, 10);
     return x[t] ?? x[e];
   }
 }
-function St(n) {
-  const t = U(n);
+function Ct(n) {
+  const t = O(n);
   if (t === void 0) return !1;
   const e = t.substring(0, 10);
   return t in x || e in x;
 }
-function K(n) {
+function D(n) {
   console.error("[Contract Error] Raw error:", n);
-  const t = U(n);
+  const t = O(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 s = t.substring(0, 10), o = x[t] ?? x[s];
+    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")) {
@@ -616,61 +619,102 @@ function K(n) {
   }
   throw n instanceof Error ? (console.error("[Contract Error] Unhandled error:", n.message), n) : new Error(`Contract call failed: ${String(n)}`);
 }
-class Ct {
+class Ut {
   /**
    * Creates a new PeginManager instance.
    *
    * @param config - Manager configuration including wallets and contract addresses
    */
   constructor(t) {
-    I(this, "config");
+    H(this, "config");
     this.config = t;
   }
   /**
-   * Prepares a peg-in transaction by building and funding it.
+   * Prepares an atomic swap 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 PSBT using primitives
-   * 3. Select UTXOs using iterative fee calculation
-   * 4. Fund transaction by adding inputs and change output
+   * 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 transaction is funded but unsigned. Use `signAndBroadcast()`
-   * to complete the Bitcoin side, and `registerPeginOnChain()` for Ethereum.
+   * The returned `fundedPrePeginTxHex` is funded but unsigned (inputs unsigned).
+   * Use `signAndBroadcast()` AFTER registering on Ethereum to broadcast it.
    *
-   * @param params - Peg-in parameters including amount, provider, UTXOs, and fee rate
-   * @returns Peg-in result with funded transaction and selection details
+   * @param params - Atomic pegin parameters including amount, HTLC params, UTXOs
+   * @returns Atomic 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(), 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({
+  async prepareAtomicPegin(t) {
+    const e = await this.config.btcWallet.getPublicKeyHex(), s = e.length === 66 ? e.slice(2) : e, o = k(t.vaultProviderBtcPubkey), r = t.vaultKeeperBtcPubkeys.map(k), c = t.universalChallengerBtcPubkeys.map(k), i = {
       depositorPubkey: s,
-      vaultProviderPubkey: a,
-      vaultKeeperPubkeys: o,
-      universalChallengerPubkeys: u,
-      timelockPegin: t.timelockPegin,
+      vaultProviderPubkey: o,
+      vaultKeeperPubkeys: r,
+      universalChallengerPubkeys: c,
+      hashH: t.hashH,
+      timelockRefund: t.timelockRefund,
       pegInAmount: t.amount,
-      depositorClaimValue: t.depositorClaimValue,
+      feeRate: BigInt(t.feeRate),
+      numLocalChallengers: t.numLocalChallengers,
+      councilQuorum: t.councilQuorum,
+      councilSize: t.councilSize,
       network: this.config.btcNetwork
-    }), r = t.amount + t.depositorClaimValue, c = nt(
-      t.availableUTXOs,
-      r,
+    }, a = await tt(i), u = ct(
+      [...t.availableUTXOs],
+      a.totalOutputValue,
       t.feeRate
-    ), l = C(this.config.btcNetwork), d = rt({
-      unfundedTxHex: i.psbtHex,
-      selectedUTXOs: c.selectedUTXOs,
+    ), l = U(this.config.btcNetwork), d = et({
+      unfundedTxHex: a.psbtHex,
+      selectedUTXOs: u.selectedUTXOs,
       changeAddress: t.changeAddress,
-      changeAmount: c.changeAmount,
+      changeAmount: u.changeAmount,
       network: l
-    }), f = R(d);
+    }), f = k(X(d)), h = await nt({
+      prePeginParams: i,
+      timelockPegin: t.timelockPegin,
+      fundedPrePeginTxid: f
+    }), m = await st({
+      peginTxHex: h.txHex,
+      fundedPrePeginTxHex: d,
+      depositorPubkey: s,
+      vaultProviderPubkey: o,
+      vaultKeeperPubkeys: r,
+      universalChallengerPubkeys: c,
+      hashH: t.hashH,
+      timelockRefund: t.timelockRefund,
+      network: this.config.btcNetwork
+    }), P = await this.config.btcWallet.signPsbt(
+      m.psbtHex,
+      {
+        autoFinalized: !1,
+        signInputs: [
+          {
+            index: 0,
+            publicKey: e,
+            disableTweakSigner: !0
+          }
+        ]
+      }
+    ), p = rt(
+      P,
+      s
+    );
     return {
-      btcTxHash: T(f),
-      fundedTxHex: d,
-      vaultScriptPubKey: i.vaultScriptPubKey,
-      selectedUTXOs: c.selectedUTXOs,
-      fee: c.fee,
-      changeAmount: c.changeAmount,
-      ethTxHash: null
+      fundedPrePeginTxHex: d,
+      htlcValue: a.htlcValue,
+      signedPeginInputPsbtHex: P,
+      peginInputSignature: p,
+      vaultScriptPubKey: h.vaultScriptPubKey,
+      peginTxHex: h.txHex,
+      prePeginTxid: f,
+      peginTxid: h.txid,
+      selectedUTXOs: u.selectedUTXOs,
+      fee: u.fee,
+      changeAmount: u.changeAmount
     };
   }
   /**
@@ -689,57 +733,63 @@ class Ct {
    * @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)
+    const { fundedPrePeginTxHex: e, depositorBtcPubkey: s } = t, o = e.startsWith("0x") ? e.slice(2) : e, r = S.fromHex(o);
+    if (r.ins.length === 0)
       throw new Error("Transaction has no inputs");
-    const u = new S();
-    u.setVersion(o.version), u.setLocktime(o.locktime);
+    const c = new C();
+    c.setVersion(r.version), c.setLocktime(r.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)
+    const a = g.from(i, "hex");
+    if (a.length !== 32)
       throw new Error(
-        `Invalid depositorBtcPubkey length: expected 32 bytes, got ${r.length}`
+        `Invalid depositorBtcPubkey length: expected 32 bytes, got ${a.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,
+    const u = this.config.mempoolApiUrl, l = r.ins.map((p) => {
+      const y = g.from(p.hash).reverse().toString("hex"), b = p.index;
+      return gt(y, b, u).then((w) => ({
+        input: p,
+        utxoData: w,
         txid: y,
-        vout: m
+        vout: b
       }));
     }), d = await Promise.all(l);
-    for (const { input: h, utxoData: y, txid: m, vout: P } of d) {
-      const w = at(
+    for (const { input: p, utxoData: y, txid: b, vout: w } of d) {
+      const T = lt(
         {
           value: y.value,
           scriptPubKey: y.scriptPubKey
         },
-        r
+        a
       );
-      u.addInput({
-        hash: h.hash,
-        index: h.index,
-        sequence: h.sequence,
-        ...w
+      c.addInput({
+        hash: p.hash,
+        index: p.index,
+        sequence: p.sequence,
+        ...T
       });
     }
-    for (const h of o.outs)
-      u.addOutput({
-        script: h.script,
-        value: h.value
+    for (const p of r.outs)
+      c.addOutput({
+        script: p.script,
+        value: p.value
       });
-    const f = await this.config.btcWallet.signPsbt(u.toHex()), g = S.fromHex(f);
+    const f = await this.config.btcWallet.signPsbt(c.toHex()), h = C.fromHex(f);
     try {
-      g.finalizeAllInputs();
-    } catch {
+      h.finalizeAllInputs();
+    } catch (p) {
+      if (!h.data.inputs.every(
+        (b) => b.finalScriptWitness || b.finalScriptSig
+      ))
+        throw new Error(
+          `PSBT finalization failed and wallet did not auto-finalize: ${p}`
+        );
     }
-    const b = g.extractTransaction().toHex();
-    return await ct(b, c);
+    const m = h.extractTransaction().toHex();
+    return await pt(m, u);
   }
   /**
    * Registers a peg-in on Ethereum by calling the BTCVaultsManager contract.
@@ -761,83 +811,87 @@ class Ct {
   async registerPeginOnChain(t) {
     const {
       depositorBtcPubkey: e,
-      unsignedBtcTx: s,
-      vaultProvider: a,
-      onPopSigned: o,
-      depositorPayoutBtcAddress: u,
-      depositorLamportPkHash: i,
-      preSignedBtcPopSignature: r
+      unsignedPrePeginTx: s,
+      depositorSignedPeginTx: o,
+      vaultProvider: r,
+      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 c = this.config.ethWallet.account.address, l = await this.resolvePopSignature(
-      c,
-      r
+    const d = this.config.ethWallet.account.address, f = await this.resolvePopSignature(
+      d,
+      l
     );
-    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))
+    i && await i();
+    const h = I(e), m = I(s), P = I(o), p = await this.resolvePayoutScriptPubKey(
+      a
+    ), y = X(P);
+    if (await this.checkVaultExists(y))
       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.`
+        `Vault already exists for this transaction (ID: ${y}). 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({
+    const w = K({
       chain: this.config.ethChain,
-      transport: M()
+      transport: N()
     });
-    let y;
+    let T;
     try {
-      y = await h.readContract({
+      T = await w.readContract({
         address: this.config.vaultContracts.btcVaultsManager,
-        abi: B,
+        abi: $,
         functionName: "getPegInFee",
-        args: [a]
+        args: [r]
       });
     } 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,
+    const A = ot({
+      abi: $,
       functionName: "submitPeginRequest",
       args: [
-        c,
         d,
-        l,
+        h,
         f,
-        a,
-        g,
-        i
+        m,
+        P,
+        r,
+        c,
+        p,
+        u
       ]
     });
-    let P;
+    let F;
     try {
-      P = await h.estimateGas({
+      F = await w.estimateGas({
         to: this.config.vaultContracts.btcVaultsManager,
-        data: m,
-        value: y,
+        data: A,
+        value: T,
         account: this.config.ethWallet.account.address
       });
-    } catch (w) {
-      K(w);
+    } catch (v) {
+      D(v);
     }
     try {
       return {
         ethTxHash: await this.config.ethWallet.sendTransaction({
           to: this.config.vaultContracts.btcVaultsManager,
-          data: m,
-          value: y,
+          data: A,
+          value: T,
           account: this.config.ethWallet.account,
           chain: this.config.ethChain,
-          gas: P
+          gas: F
         }),
-        vaultId: b,
-        btcPopSignature: l
+        vaultId: y,
+        btcPopSignature: f
       };
-    } catch (w) {
-      K(w);
+    } catch (v) {
+      D(v);
     }
   }
   /**
@@ -848,15 +902,15 @@ class Ct {
    */
   async checkVaultExists(t) {
     try {
-      return (await F({
+      return (await K({
         chain: this.config.ethChain,
-        transport: M()
+        transport: N()
       }).readContract({
         address: this.config.vaultContracts.btcVaultsManager,
-        abi: B,
+        abi: $,
         functionName: "getBTCVault",
         args: [t]
-      })).depositor !== J;
+      })).depositor !== it;
     } catch {
       return !1;
     }
@@ -874,19 +928,19 @@ class Ct {
       e = t;
     else {
       e = await this.config.btcWallet.getAddress();
-      const a = await this.config.btcWallet.getPublicKeyHex();
-      if (!j(
+      const o = await this.config.btcWallet.getPublicKeyHex();
+      if (!at(
         e,
-        a,
+        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 s = C(this.config.btcNetwork);
+    const s = U(this.config.btcNetwork);
     try {
-      return `0x${$.address.toOutputScript(e, s).toString("hex")}`;
+      return `0x${L.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.`
@@ -902,11 +956,11 @@ class Ct {
   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,
+    const s = this.config.vaultContracts.btcVaultsManager, o = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${s.toLowerCase()}`, r = await this.config.btcWallet.signMessage(
+      o,
       "bip322-simple"
     );
-    return o.startsWith("0x") ? o : `0x${p.from(o, "base64").toString("hex")}`;
+    return r.startsWith("0x") ? r : `0x${g.from(r, "base64").toString("hex")}`;
   }
   /**
    * Gets the configured Bitcoin network.
@@ -925,14 +979,14 @@ class Ct {
     return this.config.vaultContracts.btcVaultsManager;
   }
 }
-class Ht {
+class Ot {
   /**
    * Creates a new PayoutManager instance.
    *
    * @param config - Manager configuration including wallet
    */
   constructor(t) {
-    I(this, "config");
+    H(this, "config");
     this.config = t;
   }
   /**
@@ -958,10 +1012,10 @@ class Ht {
    * @throws Error if wallet operations fail or signature extraction fails
    */
   async signPayoutTransaction(t) {
-    const e = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: s } = A(
+    const e = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: s } = V(
       e,
       t.depositorBtcPubkey
-    ), a = await O({
+    ), o = await M({
       payoutTxHex: t.payoutTxHex,
       peginTxHex: t.peginTxHex,
       assertTxHex: t.assertTxHex,
@@ -971,8 +1025,8 @@ class Ht {
       universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
       timelockPegin: t.timelockPegin,
       network: this.config.network
-    }), o = await this.config.btcWallet.signPsbt(
-      a.psbtHex,
+    }), r = await this.config.btcWallet.signPsbt(
+      o.psbtHex,
       {
         autoFinalized: !1,
         signInputs: [
@@ -985,7 +1039,7 @@ class Ht {
       }
     );
     return {
-      signature: W(o, s),
+      signature: R(r, s),
       depositorBtcPubkey: s
     };
   }
@@ -1019,25 +1073,25 @@ class Ht {
       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(
+    const e = await this.config.btcWallet.getPublicKeyHex(), s = [], o = [], r = [];
+    for (const a of t) {
+      const { depositorPubkey: u } = V(
         e,
-        r.depositorBtcPubkey
+        a.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,
+      r.push(u);
+      const l = await M({
+        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
       });
-      s.push(l.psbtHex), a.push({
+      s.push(l.psbtHex), o.push({
         autoFinalized: !1,
         signInputs: [
           {
@@ -1048,65 +1102,54 @@ class Ht {
         ]
       });
     }
-    const u = await this.config.btcWallet.signPsbts(
+    const c = await this.config.btcWallet.signPsbts(
       s,
-      a
+      o
     );
-    if (u.length !== t.length)
+    if (c.length !== t.length)
       throw new Error(
-        `Expected ${t.length} signed PSBTs but received ${u.length}`
+        `Expected ${t.length} signed PSBTs but received ${c.length}`
       );
     const i = [];
-    for (let r = 0; r < t.length; r++) {
-      const c = o[r], l = W(
-        u[r],
-        c
+    for (let a = 0; a < t.length; a++) {
+      const u = r[a], l = R(
+        c[a],
+        u
       );
       i.push({
         payoutSignature: l,
-        depositorBtcPubkey: c
+        depositorBtcPubkey: u
       });
     }
     return i;
   }
 }
 export {
-  St as A,
-  N as B,
+  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,
+  dt as M,
+  Ut as P,
   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,
+  vt as b,
+  X as c,
+  kt as d,
+  ut as e,
+  lt as f,
+  Tt as g,
+  Ot as h,
+  Ht as i,
+  Et as j,
+  St 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
+  Bt as m,
+  ht as n,
+  gt as o,
+  pt as p,
+  $ as q,
+  O as r,
+  ct as s,
+  $t as t,
+  Ct as u,
+  D as v
 };
-//# sourceMappingURL=PayoutManager-rMj54HDh.js.map
+//# sourceMappingURL=PayoutManager-BK1jKgL5.js.map