@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/dist/chunk-5FUB65LX.js

@@ -1,838 +0,0 @@
-import {
-  encodeSparkAddress
-} from "./chunk-KMUMFYFX.js";
-import {
-  getNetwork,
-  getNetworkFromAddress
-} from "./chunk-Z5HIAYFT.js";
-import {
-  ELECTRS_CREDENTIALS,
-  getElectrsUrl
-} from "./chunk-R5PXJZQS.js";
-import {
-  BitcoinNetwork_default
-} from "./chunk-HMLOC6TE.js";
-import {
-  ValidationError
-} from "./chunk-GSI4OLXZ.js";
-import {
-  TreeNode
-} from "./chunk-BGGEVUJK.js";
-import {
-  Buffer
-} from "./chunk-MVRQ5US7.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 checkIfValidSequence(currSequence) {
-  const TIME_LOCK_ACTIVE = (currSequence || 0) & 2147483648;
-  if (TIME_LOCK_ACTIVE !== 0) {
-    throw new ValidationError("Timelock not active", {
-      field: "currSequence",
-      value: currSequence
-    });
-  }
-  const RELATIVE_TIME_LOCK_ACTIVE = (currSequence || 0) & 4194304;
-  if (RELATIVE_TIME_LOCK_ACTIVE !== 0) {
-    throw new ValidationError("Block based timelock not active", {
-      field: "currSequence",
-      value: currSequence
-    });
-  }
-}
-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 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
-  };
-}
-
-// src/utils/xchain-address.ts
-import * as btc3 from "@scure/btc-signer";
-var networkByType = {
-  MAINNET: btc3.NETWORK,
-  TESTNET: btc3.TEST_NETWORK,
-  REGTEST: {
-    ...btc3.TEST_NETWORK,
-    bech32: "bcrt"
-  }
-};
-function getSparkAddressFromTaproot(taprootAddress) {
-  for (const networkType of ["MAINNET", "TESTNET", "REGTEST"]) {
-    try {
-      const result = btc3.Address(networkByType[networkType]).decode(taprootAddress);
-      if (result.type === "tr") {
-        const outputPublicKey = result.pubkey;
-        return encodeSparkAddress({
-          identityPublicKey: Buffer.concat([
-            Buffer.from([2]),
-            outputPublicKey
-          ]).toString("hex"),
-          network: networkType
-        });
-      }
-    } catch (_) {
-    }
-  }
-  throw new ValidationError("Invalid taproot address");
-}
-
-export {
-  computeTaprootKeyNoScript,
-  getP2TRScriptFromPublicKey,
-  getP2TRAddressFromPublicKey,
-  getP2TRAddressFromPkScript,
-  getP2WPKHAddressFromPublicKey,
-  getTxFromRawTxHex,
-  getTxFromRawTxBytes,
-  getSigHashFromTx,
-  getTxId,
-  getTxIdNoReverse,
-  DEFAULT_FEE_SATS,
-  maybeApplyFee,
-  createRefundTx,
-  getCurrentTimelock,
-  getTransactionSequence,
-  checkIfValidSequence,
-  getNextTransactionSequence,
-  getEphemeralAnchorOutput,
-  getTransferPackageSigningPayload,
-  proofOfPossessionMessageHashForDepositAddress,
-  getLatestDepositTxId,
-  isTxBroadcast,
-  isEphemeralAnchorOutput,
-  constructUnilateralExitTxs,
-  constructUnilateralExitFeeBumpPackages,
-  constructFeeBumpTx,
-  getSparkAddressFromTaproot
-};