@buildonspark/spark-sdk 0.1.39 → 0.1.40

package/dist/chunk-ED3ZAFDI.js

@@ -0,0 +1,784 @@
+import {
+  getNetwork,
+  getNetworkFromAddress
+} from "./chunk-HK6LPV6Z.js";
+import {
+  ELECTRS_CREDENTIALS,
+  getElectrsUrl
+} from "./chunk-ZUVYYR5T.js";
+import {
+  BitcoinNetwork_default
+} from "./chunk-HMLOC6TE.js";
+import {
+  ValidationError
+} from "./chunk-TWF35O6M.js";
+import {
+  TreeNode
+} from "./chunk-C5LTJBI7.js";
+
+// src/utils/bitcoin.ts
+import {
+  bytesToHex,
+  bytesToNumberBE,
+  hexToBytes
+} from "@noble/curves/abstract/utils";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { sha256 } from "@noble/hashes/sha2";
+import * as btc from "@scure/btc-signer";
+function computeTaprootKeyNoScript(pubkey) {
+  if (pubkey.length !== 32) {
+    throw new ValidationError("Public key must be 32 bytes", {
+      field: "pubkey",
+      value: pubkey.length,
+      expected: 32
+    });
+  }
+  const taggedHash = schnorr.utils.taggedHash("TapTweak", pubkey);
+  const tweak = bytesToNumberBE(taggedHash);
+  const P = schnorr.utils.lift_x(schnorr.utils.bytesToNumberBE(pubkey));
+  const Q = P.add(secp256k1.ProjectivePoint.fromPrivateKey(tweak));
+  return Q.toRawBytes();
+}
+function getP2TRScriptFromPublicKey(pubKey, network) {
+  if (pubKey.length !== 33) {
+    throw new ValidationError("Public key must be 33 bytes", {
+      field: "pubKey",
+      value: pubKey.length,
+      expected: 33
+    });
+  }
+  const internalKey = secp256k1.ProjectivePoint.fromHex(pubKey);
+  const script = btc.p2tr(
+    internalKey.toRawBytes().slice(1, 33),
+    void 0,
+    getNetwork(network)
+  ).script;
+  if (!script) {
+    throw new ValidationError("Failed to get P2TR script", {
+      field: "script",
+      value: "null"
+    });
+  }
+  return script;
+}
+function getP2TRAddressFromPublicKey(pubKey, network) {
+  if (pubKey.length !== 33) {
+    throw new ValidationError("Public key must be 33 bytes", {
+      field: "pubKey",
+      value: pubKey.length,
+      expected: 33
+    });
+  }
+  const internalKey = secp256k1.ProjectivePoint.fromHex(pubKey);
+  const address = btc.p2tr(
+    internalKey.toRawBytes().slice(1, 33),
+    void 0,
+    getNetwork(network)
+  ).address;
+  if (!address) {
+    throw new ValidationError("Failed to get P2TR address", {
+      field: "address",
+      value: "null"
+    });
+  }
+  return address;
+}
+function getP2TRAddressFromPkScript(pkScript, network) {
+  if (pkScript.length !== 34 || pkScript[0] !== 81 || pkScript[1] !== 32) {
+    throw new ValidationError("Invalid pkscript", {
+      field: "pkScript",
+      value: bytesToHex(pkScript),
+      expected: "34 bytes starting with 0x51 0x20"
+    });
+  }
+  const parsedScript = btc.OutScript.decode(pkScript);
+  return btc.Address(getNetwork(network)).encode(parsedScript);
+}
+function getP2WPKHAddressFromPublicKey(pubKey, network) {
+  if (pubKey.length !== 33) {
+    throw new ValidationError("Public key must be 33 bytes", {
+      field: "pubKey",
+      value: pubKey.length,
+      expected: 33
+    });
+  }
+  const address = btc.p2wpkh(pubKey, getNetwork(network)).address;
+  if (!address) {
+    throw new ValidationError("Failed to get P2WPKH address", {
+      field: "address",
+      value: "null"
+    });
+  }
+  return address;
+}
+function getTxFromRawTxHex(rawTxHex) {
+  const txBytes = hexToBytes(rawTxHex);
+  const tx = btc.Transaction.fromRaw(txBytes, {
+    allowUnknownOutputs: true
+  });
+  if (!tx) {
+    throw new ValidationError("Failed to parse transaction", {
+      field: "tx",
+      value: "null"
+    });
+  }
+  return tx;
+}
+function getTxFromRawTxBytes(rawTxBytes) {
+  const tx = btc.Transaction.fromRaw(rawTxBytes, {
+    allowUnknownOutputs: true
+  });
+  if (!tx) {
+    throw new ValidationError("Failed to parse transaction", {
+      field: "tx",
+      value: "null"
+    });
+  }
+  return tx;
+}
+function getSigHashFromTx(tx, inputIndex, prevOutput) {
+  const prevScript = prevOutput.script;
+  if (!prevScript) {
+    throw new ValidationError("No script found in prevOutput", {
+      field: "prevScript",
+      value: "null"
+    });
+  }
+  const amount = prevOutput.amount;
+  if (!amount) {
+    throw new ValidationError("No amount found in prevOutput", {
+      field: "amount",
+      value: "null"
+    });
+  }
+  return tx.preimageWitnessV1(
+    inputIndex,
+    new Array(tx.inputsLength).fill(prevScript),
+    btc.SigHash.DEFAULT,
+    new Array(tx.inputsLength).fill(amount)
+  );
+}
+function getTxId(tx) {
+  return bytesToHex(sha256(sha256(tx.toBytes(true))).reverse());
+}
+function getTxIdNoReverse(tx) {
+  return bytesToHex(sha256(sha256(tx.toBytes(true))));
+}
+
+// src/utils/mempool.ts
+async function getLatestDepositTxId(address) {
+  const network = getNetworkFromAddress(address);
+  const baseUrl = network === BitcoinNetwork_default.REGTEST ? getElectrsUrl("REGTEST") : getElectrsUrl("MAINNET");
+  const headers = {};
+  if (network === BitcoinNetwork_default.REGTEST) {
+    const auth = btoa(
+      `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
+    );
+    headers["Authorization"] = `Basic ${auth}`;
+  }
+  const response = await fetch(`${baseUrl}/address/${address}/txs`, {
+    headers
+  });
+  const addressTxs = await response.json();
+  if (addressTxs && addressTxs.length > 0) {
+    const latestTx = addressTxs[0];
+    const outputIndex = latestTx.vout.findIndex(
+      (output) => output.scriptpubkey_address === address
+    );
+    if (outputIndex === -1) {
+      return null;
+    }
+    return latestTx.txid;
+  }
+  return null;
+}
+async function isTxBroadcast(txid, baseUrl, network) {
+  const headers = {};
+  if (network === 3 /* REGTEST */) {
+    const auth = btoa(
+      `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
+    );
+    headers["Authorization"] = `Basic ${auth}`;
+  }
+  const response = await fetch(`${baseUrl}/tx/${txid}`, {
+    headers
+  });
+  const tx = await response.json();
+  if (tx.error) {
+    return false;
+  }
+  return true;
+}
+
+// src/utils/proof.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2";
+function proofOfPossessionMessageHashForDepositAddress(userPubkey, operatorPubkey, depositAddress) {
+  const encoder = new TextEncoder();
+  const depositAddressBytes = encoder.encode(depositAddress);
+  const proofMsg = new Uint8Array([
+    ...userPubkey,
+    ...operatorPubkey,
+    ...depositAddressBytes
+  ]);
+  return sha2562(proofMsg);
+}
+
+// src/utils/transfer_package.ts
+import { hexToBytes as hexToBytes2 } from "@noble/curves/abstract/utils";
+import { sha256 as sha2563 } from "@noble/hashes/sha2";
+function getTransferPackageSigningPayload(transferID, transferPackage) {
+  const encryptedPayload = transferPackage.keyTweakPackage;
+  const pairs = Object.entries(
+    encryptedPayload
+  ).map(([key, value]) => ({ key, value }));
+  pairs.sort((a, b) => a.key.localeCompare(b.key));
+  const encoder = new TextEncoder();
+  let message = hexToBytes2(transferID.replaceAll("-", ""));
+  for (const pair of pairs) {
+    const keyPart = encoder.encode(pair.key + ":");
+    const separator = encoder.encode(";");
+    message = new Uint8Array([
+      ...message,
+      ...keyPart,
+      ...pair.value,
+      ...separator
+    ]);
+  }
+  return sha2563(message);
+}
+
+// src/utils/transaction.ts
+import { Transaction as Transaction2 } from "@scure/btc-signer";
+var TIME_LOCK_INTERVAL = 100;
+var ESTIMATED_TX_SIZE = 191;
+var DEFAULT_SATS_PER_VBYTE = 5;
+var DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
+function maybeApplyFee(amount) {
+  if (amount > BigInt(DEFAULT_FEE_SATS)) {
+    return amount - BigInt(DEFAULT_FEE_SATS);
+  }
+  return amount;
+}
+function createRefundTx(sequence, nodeOutPoint, amountSats, receivingPubkey, network) {
+  const newRefundTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  newRefundTx.addInput({
+    ...nodeOutPoint,
+    sequence
+  });
+  const refundPkScript = getP2TRScriptFromPublicKey(receivingPubkey, network);
+  newRefundTx.addOutput({
+    script: refundPkScript,
+    amount: amountSats
+  });
+  newRefundTx.addOutput(getEphemeralAnchorOutput());
+  return newRefundTx;
+}
+function getCurrentTimelock(currSequence) {
+  return (currSequence || 0) & 65535;
+}
+function getTransactionSequence(currSequence) {
+  const timelock = getCurrentTimelock(currSequence);
+  return 1 << 30 | timelock;
+}
+function getNextTransactionSequence(currSequence, forRefresh) {
+  const currentTimelock = getCurrentTimelock(currSequence);
+  const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
+  if (forRefresh && nextTimelock <= 100 && currentTimelock > 0) {
+    return {
+      nextSequence: 1 << 30 | nextTimelock,
+      needRefresh: true
+    };
+  }
+  if (nextTimelock < 0) {
+    throw new ValidationError("timelock interval is less than or equal to 0", {
+      field: "nextTimelock",
+      value: nextTimelock
+    });
+  }
+  return {
+    nextSequence: 1 << 30 | nextTimelock,
+    needRefresh: nextTimelock <= 100
+  };
+}
+function getEphemeralAnchorOutput() {
+  return {
+    script: new Uint8Array([81, 2, 78, 115]),
+    // Pay-to-anchor (P2A) ephemeral anchor output
+    amount: 0n
+  };
+}
+
+// src/utils/unilateral-exit.ts
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes3 } from "@noble/curves/abstract/utils";
+import { ripemd160 } from "@noble/hashes/legacy";
+import { sha256 as sha2564 } from "@noble/hashes/sha2";
+import * as btc2 from "@scure/btc-signer";
+function isEphemeralAnchorOutput(script, amount) {
+  return Boolean(
+    amount === 0n && script && // Pattern 1: Bare OP_TRUE (single byte 0x51)
+    (script.length === 1 && script[0] === 81 || // Pattern 2: Push OP_TRUE (two bytes 0x01 0x51) - MALFORMED but we detect it
+    script.length === 2 && script[0] === 1 && script[1] === 81 || // Pattern 3: Bitcoin v29 ephemeral anchor script (7 bytes: 015152014e0173)
+    script.length === 7 && script[0] === 1 && script[1] === 81 && script[2] === 82 && script[3] === 1 && script[4] === 78 && script[5] === 1 && script[6] === 115 || // Pattern 4: Bitcoin ephemeral anchor OP_1 + push 2 bytes (4 bytes: 51024e73)
+    script.length === 4 && script[0] === 81 && script[1] === 2 && script[2] === 78 && script[3] === 115)
+  );
+}
+async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
+  const result = [];
+  const nodes = nodeHexStrings.map((hex) => TreeNode.decode(hexToBytes3(hex)));
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.id, node);
+  }
+  for (const node of nodes) {
+    const transactions = [];
+    const chain = [];
+    let currentNode = node;
+    while (currentNode) {
+      chain.unshift(currentNode);
+      if (currentNode.parentNodeId) {
+        let parentNode = nodeMap.get(currentNode.parentNodeId);
+        if (!parentNode && sparkClient) {
+          try {
+            const response = await sparkClient.query_nodes({
+              source: {
+                $case: "nodeIds",
+                nodeIds: {
+                  nodeIds: [currentNode.parentNodeId]
+                }
+              },
+              includeParents: true,
+              network: network || 0
+              // Default to mainnet if not provided
+            });
+            parentNode = response.nodes[currentNode.parentNodeId];
+            if (parentNode) {
+              nodeMap.set(currentNode.parentNodeId, parentNode);
+            }
+          } catch (error) {
+            console.warn(
+              `Failed to query parent node ${currentNode.parentNodeId}: ${error}`
+            );
+            break;
+          }
+        }
+        if (parentNode) {
+          currentNode = parentNode;
+        } else {
+          if (!sparkClient) {
+            console.warn(
+              `Parent node ${currentNode.parentNodeId} not found. Provide a sparkClient to fetch missing parents.`
+            );
+          } else {
+            console.warn(
+              `Parent node ${currentNode.parentNodeId} not found in database. Chain may be incomplete.`
+            );
+          }
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    for (const chainNode of chain) {
+      const nodeTx = bytesToHex2(chainNode.nodeTx);
+      transactions.push(nodeTx);
+      if (chainNode.id === node.id) {
+        const refundTx = bytesToHex2(chainNode.refundTx);
+        transactions.push(refundTx);
+      }
+    }
+    result.push({
+      leafId: node.id,
+      transactions
+    });
+  }
+  return result;
+}
+async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, feeRate, electrsUrl, sparkClient, network) {
+  const result = [];
+  const availableUtxos = [...utxos].sort((a, b) => {
+    if (a.value > b.value) return -1;
+    if (a.value < b.value) return 1;
+    return 0;
+  });
+  const nodes = [];
+  for (let i = 0; i < nodeHexStrings.length; i++) {
+    const hex = nodeHexStrings[i];
+    try {
+      if (!hex || hex.length === 0) {
+        throw new Error(`Node hex string at index ${i} is empty`);
+      }
+      if (hex.startsWith("03000000") || hex.startsWith("02000000") || hex.startsWith("01000000")) {
+        throw new Error(
+          `Node hex string at index ${i} appears to be a raw transaction hex, not a TreeNode protobuf. Use 'leafidtohex' command to convert node IDs to proper hex strings.`
+        );
+      }
+      const nodeBytes = hexToBytes3(hex);
+      const node = TreeNode.decode(nodeBytes);
+      if (!node.id) {
+        throw new Error(
+          `Decoded TreeNode at index ${i} is missing required 'id' field`
+        );
+      }
+      if (!node.nodeTx || node.nodeTx.length === 0) {
+        throw new Error(
+          `Decoded TreeNode at index ${i} is missing required 'nodeTx' field`
+        );
+      }
+      nodes.push(node);
+    } catch (decodeError) {
+      throw new Error(
+        `Failed to decode TreeNode hex string at index ${i}: ${decodeError}. Make sure you're providing TreeNode protobuf hex strings, not raw transaction hex. Use 'leafidtohex' command to get proper hex strings.`
+      );
+    }
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.id, node);
+  }
+  const broadcastTxs = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const txPackages = [];
+    let previousFeeBumpTx;
+    const chain = [];
+    let currentNode = node;
+    while (currentNode) {
+      chain.unshift(currentNode);
+      if (currentNode.parentNodeId) {
+        let parentNode = nodeMap.get(currentNode.parentNodeId);
+        if (!parentNode && sparkClient) {
+          try {
+            const response = await sparkClient.query_nodes({
+              source: {
+                $case: "nodeIds",
+                nodeIds: {
+                  nodeIds: [currentNode.parentNodeId]
+                }
+              },
+              includeParents: true,
+              network: network || 0
+              // Default to mainnet if not provided
+            });
+            parentNode = response.nodes[currentNode.parentNodeId];
+            if (parentNode) {
+              nodeMap.set(currentNode.parentNodeId, parentNode);
+            }
+          } catch (error) {
+            console.warn(
+              `Failed to query parent node ${currentNode.parentNodeId}: ${error}`
+            );
+            break;
+          }
+        }
+        if (parentNode) {
+          currentNode = parentNode;
+        } else {
+          if (!sparkClient) {
+            console.warn(
+              `Parent node ${currentNode.parentNodeId} not found. Provide a sparkClient to fetch missing parents.`
+            );
+          } else {
+            console.warn(
+              `Parent node ${currentNode.parentNodeId} not found in database. Chain may be incomplete.`
+            );
+          }
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    for (const chainNode of chain) {
+      let nodeTxHex = bytesToHex2(chainNode.nodeTx);
+      try {
+        const txObj = getTxFromRawTxHex(nodeTxHex);
+        const txid = getTxId(txObj);
+        if (broadcastTxs.get(txid)) {
+          continue;
+        }
+        broadcastTxs.set(txid, true);
+        const isBroadcast = await isTxBroadcast(txid, electrsUrl, network);
+        if (isBroadcast) {
+          continue;
+        } else {
+        }
+        let anchorOutputScriptHex;
+        for (let i = txObj.outputsLength - 1; i >= 0; i--) {
+          const output = txObj.getOutput(i);
+          if (output?.amount === 0n && output.script) {
+            anchorOutputScriptHex = bytesToHex2(output.script);
+            break;
+          }
+        }
+      } catch (parseError) {
+        console.error(
+          `\u274C Error parsing nodeTx for anchor check (node ${chainNode.id}): ${parseError}`
+        );
+        console.log(
+          `    This may indicate a corrupted transaction in the TreeNode.`
+        );
+        console.log(`    Transaction hex: ${nodeTxHex}`);
+        console.log(
+          `    Attempting to continue with original hex, but fee bump may fail.`
+        );
+      }
+      const {
+        feeBumpPsbt: nodeFeeBumpPsbt,
+        usedUtxos,
+        correctedParentTx
+      } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
+      const feeBumpTx = btc2.Transaction.fromPSBT(hexToBytes3(nodeFeeBumpPsbt));
+      var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
+      var feeBumpOutPubKey = null;
+      for (const usedUtxo of usedUtxos) {
+        if (feeBumpOut && bytesToHex2(feeBumpOut.script) == usedUtxo.script) {
+          feeBumpOutPubKey = usedUtxo.publicKey;
+        }
+        const index = availableUtxos.findIndex(
+          (u) => u.txid === usedUtxo.txid && u.vout === usedUtxo.vout
+        );
+        if (index !== -1) {
+          availableUtxos.splice(index, 1);
+        }
+      }
+      if (feeBumpOut)
+        availableUtxos.unshift({
+          txid: getTxId(feeBumpTx),
+          vout: 0,
+          value: feeBumpOut.amount,
+          script: bytesToHex2(feeBumpOut.script),
+          publicKey: feeBumpOutPubKey
+        });
+      const finalNodeTx = correctedParentTx || nodeTxHex;
+      txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
+      if (chainNode.id === node.id) {
+        let refundTxHex = bytesToHex2(chainNode.refundTx);
+        try {
+          const txObj = getTxFromRawTxHex(refundTxHex);
+          let anchorOutputScriptHex;
+          for (let i = txObj.outputsLength - 1; i >= 0; i--) {
+            const output = txObj.getOutput(i);
+            if (output?.amount === 0n && output.script) {
+              anchorOutputScriptHex = bytesToHex2(output.script);
+              break;
+            }
+          }
+        } catch (parseError) {
+          console.error(
+            `\u274C Error parsing refundTx for anchor check (node ${chainNode.id}): ${parseError}`
+          );
+          console.log(
+            `    This may indicate a corrupted refund transaction in the TreeNode.`
+          );
+          console.log(`    Refund transaction hex: ${refundTxHex}`);
+          console.log(
+            `    Attempting to continue with original refund hex, but this transaction may be invalid.`
+          );
+        }
+        const refundFeeBump = constructFeeBumpTx(
+          refundTxHex,
+          availableUtxos,
+          feeRate,
+          void 0
+        );
+        txPackages.push({
+          tx: refundTxHex,
+          feeBumpPsbt: refundFeeBump.feeBumpPsbt
+        });
+      }
+    }
+    result.push({
+      leafId: node.id,
+      txPackages
+    });
+  }
+  return result;
+}
+function hash160(data) {
+  const sha256Hash = sha2564(data);
+  return ripemd160(sha256Hash);
+}
+function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
+  if (!txHex || txHex.length === 0) {
+    throw new Error("Transaction hex string is empty or undefined");
+  }
+  if (utxos.length === 0) {
+    throw new Error("No UTXOs available for fee bump");
+  }
+  let correctedTxHex = txHex;
+  let parentTx;
+  try {
+    parentTx = getTxFromRawTxHex(correctedTxHex);
+    if (!parentTx) {
+      throw new Error("getTxFromRawTxHex returned null/undefined");
+    }
+  } catch (parseError) {
+    throw new Error(
+      `Failed to parse parent transaction hex: ${parseError}. Transaction hex: ${correctedTxHex}`
+    );
+  }
+  try {
+    const outputsLength = parentTx.outputsLength;
+    const inputsLength = parentTx.inputsLength;
+    if (typeof outputsLength !== "number" || outputsLength < 0) {
+      throw new Error(
+        "Invalid transaction: outputsLength is not a valid number"
+      );
+    }
+    if (typeof inputsLength !== "number" || inputsLength < 0) {
+      throw new Error(
+        "Invalid transaction: inputsLength is not a valid number"
+      );
+    }
+  } catch (validationError) {
+    throw new Error(
+      `Transaction validation failed: ${validationError}. This may indicate a corrupted or malformed transaction.`
+    );
+  }
+  const parentTxIdFromLib = parentTx.id;
+  let ephemeralAnchorIndex = -1;
+  for (let i = 0; i < parentTx.outputsLength; i++) {
+    const output = parentTx.getOutput(i);
+    const isEphemeralAnchor = isEphemeralAnchorOutput(
+      output?.script,
+      output?.amount
+    );
+    if (isEphemeralAnchor) {
+      ephemeralAnchorIndex = i;
+      break;
+    }
+  }
+  if (ephemeralAnchorIndex === -1) {
+    throw new Error(
+      "No ephemeral anchor output found in parent transaction. Expected a 0-value output with OP_TRUE script (0x51), malformed OP_TRUE (0x0151), Bitcoin v29 ephemeral anchor script (015152014e0173), or Bitcoin OP_1 + push 2 bytes script (51024e73)."
+    );
+  }
+  const ephemeralAnchorOutput = parentTx.getOutput(ephemeralAnchorIndex);
+  if (!ephemeralAnchorOutput)
+    throw new Error("No ephemeral anchor output found");
+  if (!ephemeralAnchorOutput.script)
+    throw new Error("No script found in ephemeral anchor output");
+  if (utxos.length === 0) {
+    throw new Error("No UTXOs available for fee bump");
+  }
+  const builder = new btc2.Transaction({
+    version: 3,
+    allowUnknown: true,
+    allowLegacyWitnessUtxo: true
+  });
+  let totalValue = 0n;
+  const processedUtxos = [];
+  for (let i = 0; i < utxos.length; i++) {
+    const fundingUtxo = utxos[i];
+    if (!fundingUtxo) {
+      throw new Error(`UTXO at index ${i} is undefined`);
+    }
+    const pubKeyHash = hash160(hexToBytes3(fundingUtxo.publicKey));
+    const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
+    const providedScript = hexToBytes3(fundingUtxo.script);
+    if (bytesToHex2(scriptToUse) !== bytesToHex2(providedScript)) {
+      throw new Error(
+        `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
+      );
+    }
+    builder.addInput({
+      txid: fundingUtxo.txid,
+      index: fundingUtxo.vout,
+      sequence: 4294967295,
+      witnessUtxo: {
+        script: scriptToUse,
+        // Always P2WPKH
+        amount: fundingUtxo.value
+      }
+    });
+    totalValue += fundingUtxo.value;
+    processedUtxos.push({
+      utxo: fundingUtxo,
+      p2wpkhScript: scriptToUse
+    });
+  }
+  builder.addInput({
+    txid: parentTxIdFromLib,
+    index: ephemeralAnchorIndex,
+    sequence: 4294967295,
+    witnessUtxo: {
+      script: ephemeralAnchorOutput.script,
+      // Use the original script directly (not P2WSH wrapped)
+      amount: 0n
+    }
+  });
+  const fee = 1500n;
+  const remainingValue = totalValue - fee;
+  if (remainingValue <= 0n) {
+    throw new Error(
+      `Insufficient funds for fee bump. Required fee: ${fee} sats, Available: ${totalValue} sats`
+    );
+  }
+  if (processedUtxos.length === 0) {
+    throw new Error("No processed UTXOs available for change output");
+  }
+  const firstProcessedUtxo = processedUtxos[0];
+  if (!firstProcessedUtxo) {
+    throw new Error("First processed UTXO is undefined");
+  }
+  builder.addOutput({
+    script: firstProcessedUtxo.p2wpkhScript,
+    amount: remainingValue
+  });
+  for (let i = 0; i < processedUtxos.length; i++) {
+    const processed = processedUtxos[i];
+    if (!processed) {
+      throw new Error(`Processed UTXO at index ${i} is undefined`);
+    }
+    try {
+      builder.updateInput(i, {
+        witnessScript: processed.p2wpkhScript
+      });
+      builder.signIdx;
+    } catch (error) {
+      throw new Error(`Failed to handle funding UTXO input ${i + 1}: ${error}`);
+    }
+  }
+  let psbtHex;
+  try {
+    psbtHex = bytesToHex2(builder.toPSBT());
+  } catch (error) {
+    throw new Error(`Failed to extract transaction: ${error}`);
+  }
+  return {
+    feeBumpPsbt: psbtHex,
+    usedUtxos: utxos,
+    correctedParentTx: correctedTxHex !== txHex ? correctedTxHex : void 0
+  };
+}
+
+export {
+  computeTaprootKeyNoScript,
+  getP2TRScriptFromPublicKey,
+  getP2TRAddressFromPublicKey,
+  getP2TRAddressFromPkScript,
+  getP2WPKHAddressFromPublicKey,
+  getTxFromRawTxHex,
+  getTxFromRawTxBytes,
+  getSigHashFromTx,
+  getTxId,
+  getTxIdNoReverse,
+  DEFAULT_FEE_SATS,
+  maybeApplyFee,
+  createRefundTx,
+  getCurrentTimelock,
+  getTransactionSequence,
+  getNextTransactionSequence,
+  getEphemeralAnchorOutput,
+  getTransferPackageSigningPayload,
+  proofOfPossessionMessageHashForDepositAddress,
+  getLatestDepositTxId,
+  isTxBroadcast,
+  isEphemeralAnchorOutput,
+  constructUnilateralExitTxs,
+  constructUnilateralExitFeeBumpPackages,
+  constructFeeBumpTx
+};