@buildonspark/spark-sdk 0.1.38 → 0.1.40

package/dist/native/index.js

@@ -211,6 +211,7 @@ var NativeSparkFrost = class {
 import {
   bytesToHex as bytesToHex2,
   bytesToNumberBE as bytesToNumberBE2,
+  equalBytes as equalBytes2,
   hexToBytes
 } from "@noble/curves/abstract/utils";
 import { schnorr as schnorr2, secp256k1 as secp256k15 } from "@noble/curves/secp256k1";
@@ -738,11 +739,13 @@ function decodeBytesToSigningCommitment(bytes) {
 }
 
 // src/signer/signer.ts
-import { PARITY } from "@buildonspark/lrc20-sdk";
-import { Receipt } from "@buildonspark/lrc20-sdk";
-import { privateNegate, privateAdd } from "@bitcoinerlab/secp256k1";
+import { privateAdd, privateNegate } from "@bitcoinerlab/secp256k1";
+import {
+  fromPrivateKey,
+  PARITY,
+  Receipt
+} from "@buildonspark/lrc20-sdk";
 import { sha256 } from "@noble/hashes/sha2";
-import { fromPrivateKey } from "@buildonspark/lrc20-sdk";
 var sparkFrostModule = void 0;
 var getSparkFrostModule = async () => {
   if (isReactNative) {
@@ -1228,6 +1231,25 @@ var DefaultSparkSigner = class {
     const receiptProof = privateAdd(privateKey, pxhPubkey);
     return Buffer.from(receiptProof);
   }
+  signTransactionIndex(tx, index, publicKey) {
+    let privateKey;
+    if (equalBytes2(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.identityKey?.privateKey;
+    } else if (equalBytes2(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.depositKey?.privateKey;
+    } else {
+      privateKey = hexToBytes(
+        this.publicKeyToPrivateKeyMap.get(bytesToHex2(publicKey)) ?? ""
+      );
+    }
+    if (!privateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+        value: bytesToHex2(publicKey)
+      });
+    }
+    tx.signIdx(privateKey, index);
+  }
 };
 
 // src/signer/signer.react-native.ts
@@ -1298,7 +1320,7 @@ import { isNode as isNode4, mapCurrencyAmount } from "@lightsparkdev/core";
 import {
   bytesToHex as bytesToHex12,
   bytesToNumberBE as bytesToNumberBE7,
-  equalBytes as equalBytes4,
+  equalBytes as equalBytes5,
   hexToBytes as hexToBytes13
 } from "@noble/curves/abstract/utils";
 import { secp256k1 as secp256k115 } from "@noble/curves/secp256k1";
@@ -16313,6 +16335,14 @@ function getNetworkFromAddress(address2) {
   }
   return null;
 }
+function getNetworkFromString(network) {
+  const net = (network ?? "REGTEST").toUpperCase();
+  if (net === "MAINNET") return 0 /* MAINNET */;
+  if (net === "TESTNET") return 1 /* TESTNET */;
+  if (net === "SIGNET") return 2 /* SIGNET */;
+  if (net === "LOCAL") return 4 /* LOCAL */;
+  return 3 /* REGTEST */;
+}
 
 // src/tests/isHermeticTest.ts
 import { isNode } from "@lightsparkdev/core";
@@ -17864,8 +17894,20 @@ function getTxIdNoReverse(tx) {
 // 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({ allowUnknownOutputs: true });
+  const newRefundTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
   newRefundTx.addInput({
     ...nodeOutPoint,
     sequence
@@ -17894,7 +17936,7 @@ function getNextTransactionSequence(currSequence, forRefresh) {
       needRefresh: true
     };
   }
-  if (nextTimelock <= 0) {
+  if (nextTimelock < 0) {
     throw new ValidationError("timelock interval is less than or equal to 0", {
       field: "nextTimelock",
       value: nextTimelock
@@ -17916,7 +17958,7 @@ function getEphemeralAnchorOutput() {
 // src/services/transfer.ts
 import {
   bytesToHex as bytesToHex6,
-  equalBytes as equalBytes2,
+  equalBytes as equalBytes3,
   hexToBytes as hexToBytes5,
   numberToBytesBE as numberToBytesBE3
 } from "@noble/curves/abstract/utils";
@@ -18008,6 +18050,32 @@ var BaseTransferService = class {
     }
     return updatedTransfer;
   }
+  async deliverTransferPackage(transfer, leaves, refundSignatureMap) {
+    const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
+      transfer.id,
+      transfer.receiverIdentityPublicKey,
+      leaves,
+      refundSignatureMap
+    );
+    const transferPackage = await this.prepareTransferPackage(
+      transfer.id,
+      keyTweakInputMap,
+      leaves,
+      transfer.receiverIdentityPublicKey
+    );
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const response = await sparkClient.finalize_transfer_with_transfer_package({
+      transferId: transfer.id,
+      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      transferPackage
+    });
+    if (!response.transfer) {
+      throw new ValidationError("No transfer response from operator");
+    }
+    return response.transfer;
+  }
   async sendTransferWithKeyTweaks(leaves, receiverIdentityPubkey) {
     const transferID = uuidv7();
     const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
@@ -18279,7 +18347,7 @@ var BaseTransferService = class {
     return void 0;
   }
   compareTransfers(transfer1, transfer2) {
-    return transfer1.id === transfer2.id && equalBytes2(
+    return transfer1.id === transfer2.id && equalBytes3(
       transfer1.senderIdentityPublicKey,
       transfer2.senderIdentityPublicKey
     ) && transfer1.status === transfer2.status && transfer1.totalValue === transfer2.totalValue && transfer1.expiryTime?.getTime() === transfer2.expiryTime?.getTime() && transfer1.leaves.length === transfer2.leaves.length;
@@ -18765,9 +18833,20 @@ var TransferService = class extends BaseTransferService {
       if (!input) {
         throw Error("Could not fetch tx input");
       }
-      const newTx = new Transaction3({ allowUnknownOutputs: true });
-      for (let j = 0; j < nodeTx.outputsLength; j++) {
-        newTx.addOutput(nodeTx.getOutput(j));
+      const newTx = new Transaction3({ version: 3, allowUnknownOutputs: true });
+      const originalOutput = nodeTx.getOutput(0);
+      if (!originalOutput) {
+        throw Error("Could not get original output");
+      }
+      newTx.addOutput({
+        script: originalOutput.script,
+        amount: originalOutput.amount
+      });
+      for (let j = 1; j < nodeTx.outputsLength; j++) {
+        const additionalOutput = nodeTx.getOutput(j);
+        if (additionalOutput) {
+          newTx.addOutput(additionalOutput);
+        }
       }
       if (i === 0) {
         const currSequence = input.sequence;
@@ -18794,9 +18873,23 @@ var TransferService = class extends BaseTransferService {
       throw Error("leaf does not have refund tx");
     }
     const refundTx = getTxFromRawTxBytes(leaf?.refundTx);
-    const newRefundTx = new Transaction3({ allowUnknownOutputs: true });
-    for (let j = 0; j < refundTx.outputsLength; j++) {
-      newRefundTx.addOutput(refundTx.getOutput(j));
+    const newRefundTx = new Transaction3({
+      version: 3,
+      allowUnknownOutputs: true
+    });
+    const originalRefundOutput = refundTx.getOutput(0);
+    if (!originalRefundOutput) {
+      throw Error("Could not get original refund output");
+    }
+    newRefundTx.addOutput({
+      script: originalRefundOutput.script,
+      amount: originalRefundOutput.amount
+    });
+    for (let j = 1; j < refundTx.outputsLength; j++) {
+      const additionalOutput = refundTx.getOutput(j);
+      if (additionalOutput) {
+        newRefundTx.addOutput(additionalOutput);
+      }
     }
     const refundTxInput = refundTx.getInput(0);
     if (!refundTxInput) {
@@ -18905,10 +18998,11 @@ var TransferService = class extends BaseTransferService {
       nodeTxSignature: leafSignature,
       refundTxSignature: refundSignature
     });
-    return await sparkClient.finalize_node_signatures({
+    const result = await sparkClient.finalize_node_signatures({
       intent: 3 /* REFRESH */,
       nodeSignatures
     });
+    return result;
   }
   async extendTimelock(node, signingPubKey) {
     const nodeTx = getTxFromRawTxBytes(node.nodeTx);
@@ -18919,9 +19013,20 @@ var TransferService = class extends BaseTransferService {
       index: 0
     };
     const { nextSequence: newNodeSequence } = getNextTransactionSequence(refundSequence);
-    const newNodeTx = new Transaction3({ allowUnknownOutputs: true });
+    const newNodeTx = new Transaction3({
+      version: 3,
+      allowUnknownOutputs: true
+    });
     newNodeTx.addInput({ ...newNodeOutPoint, sequence: newNodeSequence });
-    newNodeTx.addOutput(nodeTx.getOutput(0));
+    const originalOutput = nodeTx.getOutput(0);
+    if (!originalOutput) {
+      throw Error("Could not get original node output");
+    }
+    newNodeTx.addOutput({
+      script: originalOutput.script,
+      amount: originalOutput.amount
+      // feeReducedAmount,
+    });
     newNodeTx.addOutput(getEphemeralAnchorOutput());
     const newRefundOutPoint = {
       txid: hexToBytes5(getTxId(newNodeTx)),
@@ -18935,11 +19040,16 @@ var TransferService = class extends BaseTransferService {
       initialSequence(),
       newRefundOutPoint,
       amountSats,
+      // feeReducedRefundAmount,
       signingPubKey,
       this.config.getNetwork()
     );
     const nodeSighash = getSigHashFromTx(newNodeTx, 0, nodeTx.getOutput(0));
-    const refundSighash = getSigHashFromTx(newRefundTx, 0, nodeTx.getOutput(0));
+    const refundSighash = getSigHashFromTx(
+      newRefundTx,
+      0,
+      newNodeTx.getOutput(0)
+    );
     const newNodeSigningJob = {
       signingPublicKey: signingPubKey,
       rawTx: newNodeTx.toBytes(),
@@ -19013,6 +19123,94 @@ var TransferService = class extends BaseTransferService {
       ]
     });
   }
+  async refreshTimelockRefundTx(node, signingPubKey) {
+    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+    const refundTx = getTxFromRawTxBytes(node.refundTx);
+    const currSequence = refundTx.getInput(0).sequence || 0;
+    const { nextSequence } = getNextTransactionSequence(currSequence);
+    const newRefundTx = new Transaction3({
+      version: 3,
+      allowUnknownOutputs: true
+    });
+    const originalRefundOutput = refundTx.getOutput(0);
+    if (!originalRefundOutput) {
+      throw Error("Could not get original refund output");
+    }
+    newRefundTx.addOutput({
+      script: originalRefundOutput.script,
+      amount: originalRefundOutput.amount
+    });
+    for (let j = 1; j < refundTx.outputsLength; j++) {
+      const additionalOutput = refundTx.getOutput(j);
+      if (additionalOutput) {
+        newRefundTx.addOutput(additionalOutput);
+      }
+    }
+    const refundTxInput = refundTx.getInput(0);
+    if (!refundTxInput) {
+      throw Error("refund tx doesn't have input");
+    }
+    newRefundTx.addInput({
+      ...refundTxInput,
+      sequence: nextSequence
+    });
+    const refundSigningJob = {
+      signingPublicKey: signingPubKey,
+      rawTx: newRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    };
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    const response = await sparkClient.refresh_timelock({
+      leafId: node.id,
+      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      signingJobs: [refundSigningJob]
+    });
+    if (response.signingResults.length !== 1) {
+      throw Error(
+        `Expected 1 signing result, got ${response.signingResults.length}`
+      );
+    }
+    const signingResult = response.signingResults[0];
+    if (!signingResult || !refundSigningJob.signingNonceCommitment) {
+      throw Error("Signing result or nonce commitment does not exist");
+    }
+    const rawTx = getTxFromRawTxBytes(refundSigningJob.rawTx);
+    const txOut = nodeTx.getOutput(0);
+    const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
+    const userSignature = await this.config.signer.signFrost({
+      message: rawTxSighash,
+      privateAsPubKey: signingPubKey,
+      publicKey: signingPubKey,
+      verifyingKey: signingResult.verifyingKey,
+      selfCommitment: refundSigningJob.signingNonceCommitment,
+      statechainCommitments: signingResult.signingResult?.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const signature = await this.config.signer.aggregateFrost({
+      message: rawTxSighash,
+      statechainSignatures: signingResult.signingResult?.signatureShares,
+      statechainPublicKeys: signingResult.signingResult?.publicKeys,
+      verifyingKey: signingResult.verifyingKey,
+      statechainCommitments: signingResult.signingResult?.signingNonceCommitments,
+      selfCommitment: refundSigningJob.signingNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: userSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    const result = await sparkClient.finalize_node_signatures({
+      intent: 3 /* REFRESH */,
+      nodeSignatures: [
+        {
+          nodeId: node.id,
+          nodeTxSignature: new Uint8Array(),
+          refundTxSignature: signature
+        }
+      ]
+    });
+    return result;
+  }
 };
 
 // src/services/coop-exit.ts
@@ -19180,7 +19378,7 @@ import { sha256 as sha2568 } from "@noble/hashes/sha2";
 import { hexToBytes as hexToBytes6 } from "@noble/hashes/utils";
 import * as btc3 from "@scure/btc-signer";
 import { p2tr as p2tr2, Transaction as Transaction5 } from "@scure/btc-signer";
-import { equalBytes as equalBytes3 } from "@scure/btc-signer/utils";
+import { equalBytes as equalBytes4 } from "@scure/btc-signer/utils";
 
 // src/utils/proof.ts
 import { sha256 as sha2567 } from "@noble/hashes/sha2";
@@ -19314,7 +19512,7 @@ var DepositService = class {
     depositTx,
     vout
   }) {
-    const rootTx = new Transaction5();
+    const rootTx = new Transaction5({ version: 3 });
     const output = depositTx.getOutput(vout);
     if (!output) {
       throw new ValidationError("Invalid deposit transaction output", {
@@ -19332,17 +19530,19 @@ var DepositService = class {
         expected: "Output with script and amount"
       });
     }
+    let outputAmount = amount;
     rootTx.addInput({
       txid: getTxId(depositTx),
       index: vout
     });
     rootTx.addOutput({
       script,
-      amount
+      amount: outputAmount
     });
+    rootTx.addOutput(getEphemeralAnchorOutput());
     const rootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
     const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
-    const refundTx = new Transaction5();
+    const refundTx = new Transaction5({ version: 3 });
     const sequence = 1 << 30 | INITIAL_TIME_LOCK2;
     refundTx.addInput({
       txid: getTxId(rootTx),
@@ -19357,10 +19557,11 @@ var DepositService = class {
     const refundPkScript = btc3.OutScript.encode(refundAddress);
     refundTx.addOutput({
       script: refundPkScript,
-      amount
+      amount: outputAmount
     });
+    refundTx.addOutput(getEphemeralAnchorOutput());
     const refundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const refundTxSighash = getSigHashFromTx(refundTx, 0, output);
+    const refundTxSighash = getSigHashFromTx(refundTx, 0, rootTx.getOutput(0));
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
@@ -19420,7 +19621,7 @@ var DepositService = class {
         }
       );
     }
-    if (!equalBytes3(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!equalBytes4(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -23862,7 +24063,7 @@ function isValidPublicKey(publicKey) {
 }
 
 // src/services/token-transactions.ts
-var MAX_TOKEN_OUTPUTS = 1e3;
+var MAX_TOKEN_OUTPUTS = 500;
 var TokenTransactionService = class {
   config;
   connectionManager;
@@ -24426,6 +24627,12 @@ import { hexToBytes as hexToBytes10 } from "@noble/curves/abstract/utils";
 import { sha256 as sha25612 } from "@noble/hashes/sha2";
 import { Address as Address4, OutScript as OutScript3, Transaction as Transaction7 } from "@scure/btc-signer";
 var INITIAL_TIME_LOCK3 = 2e3;
+function maybeApplyFee3(amount) {
+  if (amount > BigInt(DEFAULT_FEE_SATS)) {
+    return amount - BigInt(DEFAULT_FEE_SATS);
+  }
+  return amount;
+}
 var TreeCreationService = class {
   config;
   connectionManager;
@@ -24624,7 +24831,7 @@ var TreeCreationService = class {
       refundTxSigningJob: void 0,
       children: []
     };
-    const tx = new Transaction7();
+    const tx = new Transaction7({ version: 3 });
     tx.addInput({
       txid: getTxId(parentTx),
       index: vout
@@ -24636,6 +24843,7 @@ var TreeCreationService = class {
     tx.addOutput({
       script: parentTxOut.script,
       amount: parentTxOut.amount
+      // maybeApplyFee(parentTxOut.amount),
     });
     tx.addOutput(getEphemeralAnchorOutput());
     const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
@@ -24652,7 +24860,7 @@ var TreeCreationService = class {
       refundTxSigningJob: void 0,
       children: []
     };
-    const childTx = new Transaction7();
+    const childTx = new Transaction7({ version: 3 });
     childTx.addInput({
       txid: getTxId(tx),
       index: 0,
@@ -24661,6 +24869,7 @@ var TreeCreationService = class {
     childTx.addOutput({
       script: parentTxOut.script,
       amount: parentTxOut.amount
+      // maybeApplyFee(parentTxOut.amount),
     });
     childTx.addOutput(getEphemeralAnchorOutput());
     const childSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
@@ -24671,7 +24880,7 @@ var TreeCreationService = class {
     };
     childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
     childCreationNode.nodeTxSigningJob = childSigningJob;
-    const refundTx = new Transaction7();
+    const refundTx = new Transaction7({ version: 3 });
     refundTx.addInput({
       txid: getTxId(childTx),
       index: 0,
@@ -24687,8 +24896,9 @@ var TreeCreationService = class {
     const refundPkScript = OutScript3.encode(refundAddress);
     refundTx.addOutput({
       script: refundPkScript,
-      amount: parentTxOut.amount
+      amount: maybeApplyFee3(parentTxOut.amount)
     });
+    refundTx.addOutput(getEphemeralAnchorOutput());
     const refundSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
     const refundSigningJob = {
       signingPublicKey: node.signingPublicKey,
@@ -24705,7 +24915,7 @@ var TreeCreationService = class {
     if (!parentTxOutput?.script || !parentTxOutput?.amount) {
       throw new Error("parentTxOutput is undefined");
     }
-    const rootNodeTx = new Transaction7();
+    const rootNodeTx = new Transaction7({ version: 3 });
     rootNodeTx.addInput({
       txid: getTxId(parentTx),
       index: vout
@@ -24720,10 +24930,10 @@ var TreeCreationService = class {
       rootNodeTx.addOutput({
         script: childPkScript,
         amount: parentTxOutput.amount / 2n
+        // feeAdjustedAmount / 2n,
       });
     }
-    const anchor = getEphemeralAnchorOutput();
-    rootNodeTx.addOutput(anchor);
+    rootNodeTx.addOutput(getEphemeralAnchorOutput());
     const rootNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
     const rootNodeSigningJob = {
       signingPublicKey: root.signingPublicKey,
@@ -25410,7 +25620,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     try {
       if (event?.$case === "transfer" && event.transfer.transfer && event.transfer.transfer.type !== 40 /* COUNTER_SWAP */) {
         const { senderIdentityPublicKey, receiverIdentityPublicKey } = event.transfer.transfer;
-        if (event.transfer.transfer && !equalBytes4(senderIdentityPublicKey, receiverIdentityPublicKey)) {
+        if (event.transfer.transfer && !equalBytes5(senderIdentityPublicKey, receiverIdentityPublicKey)) {
           await this.claimTransfer({
             transfer: event.transfer.transfer,
             emit: true,
@@ -25572,10 +25782,10 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
               leavesToIgnore.add(nodeId);
               continue;
             }
-            if (leaf.status !== operatorLeaf.status || !leaf.signingKeyshare || !operatorLeaf.signingKeyshare || !equalBytes4(
+            if (leaf.status !== operatorLeaf.status || !leaf.signingKeyshare || !operatorLeaf.signingKeyshare || !equalBytes5(
               leaf.signingKeyshare.publicKey,
               operatorLeaf.signingKeyshare.publicKey
-            ) || !equalBytes4(leaf.nodeTx, operatorLeaf.nodeTx) || !equalBytes4(leaf.refundTx, operatorLeaf.refundTx)) {
+            ) || !equalBytes5(leaf.nodeTx, operatorLeaf.nodeTx) || !equalBytes5(leaf.refundTx, operatorLeaf.refundTx)) {
               leavesToIgnore.add(nodeId);
             }
           }
@@ -25583,7 +25793,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       }
     }
     const verifyKey = (pubkey1, pubkey2, verifyingKey) => {
-      return equalBytes4(addPublicKeys(pubkey1, pubkey2), verifyingKey);
+      return equalBytes5(addPublicKeys(pubkey1, pubkey2), verifyingKey);
     };
     for (const [id, leaf] of Object.entries(leaves.nodes)) {
       if (!verifyKey(
@@ -25978,7 +26188,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
           adaptorPrivateKey
         );
       }
-      await this.transferService.sendTransferTweakKey(
+      await this.transferService.deliverTransferPackage(
         transfer,
         leafKeyTweaks,
         signatureMap
@@ -26751,7 +26961,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       this.config.getNetworkType()
     );
     const signerIdentityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const isSelfTransfer = equalBytes4(
+    const isSelfTransfer = equalBytes5(
       signerIdentityPublicKey,
       hexToBytes13(receiverAddress)
     );
@@ -27663,6 +27873,112 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     }
     return this.config.signer.validateMessageWithIdentityKey(hash, signature);
   }
+  /**
+   * Signs a transaction with wallet keys.
+   *
+   * @param {string} txHex - The transaction hex to sign
+   * @param {string} keyType - The type of key to use for signing ("identity", "deposit", or "auto-detect")
+   * @returns {Promise<string>} The signed transaction hex
+   */
+  async signTransaction(txHex, keyType = "auto-detect") {
+    try {
+      const tx = Transaction9.fromRaw(hexToBytes13(txHex));
+      let publicKey;
+      switch (keyType.toLowerCase()) {
+        case "identity":
+          publicKey = await this.config.signer.getIdentityPublicKey();
+          break;
+        case "deposit":
+          publicKey = await this.config.signer.getDepositSigningKey();
+          break;
+        case "auto-detect":
+        default:
+          const detectedKey = await this.detectKeyForTransaction(tx);
+          if (detectedKey) {
+            publicKey = detectedKey.publicKey;
+          } else {
+            publicKey = await this.config.signer.getIdentityPublicKey();
+          }
+          break;
+      }
+      let inputsSigned = 0;
+      for (let i = 0; i < tx.inputsLength; i++) {
+        const input = tx.getInput(i);
+        if (!input?.witnessUtxo?.script) {
+          continue;
+        }
+        const script = input.witnessUtxo.script;
+        if (script.length === 1 && script[0] === 81) {
+          continue;
+        }
+        const identityScript = getP2TRScriptFromPublicKey(
+          publicKey,
+          this.config.getNetwork()
+        );
+        if (bytesToHex12(script) === bytesToHex12(identityScript)) {
+          try {
+            this.config.signer.signTransactionIndex(tx, i, publicKey);
+            inputsSigned++;
+          } catch (error) {
+            throw new ValidationError(`Failed to sign input ${i}: ${error}`, {
+              field: "input",
+              value: i
+            });
+          }
+        }
+      }
+      if (inputsSigned === 0) {
+        throw new Error(
+          "No inputs were signed. Check that the transaction contains inputs controlled by this wallet."
+        );
+      }
+      tx.finalize();
+      const signedTxHex = tx.hex;
+      return signedTxHex;
+    } catch (error) {
+      console.error("\u274C Error signing transaction:", error);
+      throw error;
+    }
+  }
+  /**
+   * Helper method to auto-detect which key should be used for signing a transaction.
+   */
+  async detectKeyForTransaction(tx) {
+    try {
+      const identityPubKey = await this.config.signer.getIdentityPublicKey();
+      const depositPubKey = await this.config.signer.getDepositSigningKey();
+      for (let i = 0; i < tx.inputsLength; i++) {
+        const input = tx.getInput(i);
+        if (input?.witnessUtxo?.script) {
+          const script = input.witnessUtxo.script;
+          const identityScript = getP2TRScriptFromPublicKey(
+            identityPubKey,
+            this.config.getNetwork()
+          );
+          const depositScript = getP2TRScriptFromPublicKey(
+            depositPubKey,
+            this.config.getNetwork()
+          );
+          if (bytesToHex12(script) === bytesToHex12(identityScript)) {
+            return {
+              publicKey: identityPubKey,
+              keyType: "identity"
+            };
+          }
+          if (bytesToHex12(script) === bytesToHex12(depositScript)) {
+            return {
+              publicKey: depositPubKey,
+              keyType: "deposit"
+            };
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      console.warn("Error during key auto-detection:", error);
+      return null;
+    }
+  }
   /**
    * Get a Lightning receive request by ID.
    *
@@ -27693,6 +28009,246 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const sspClient = this.getSspClient();
     return await sspClient.getCoopExitRequest(id);
   }
+  /**
+   * Check the remaining timelock on a given node.
+   *
+   * @param {string} nodeId - The ID of the node to check
+   * @returns {Promise<{nodeTimelock: number, refundTimelock: number}>} The remaining timelocks in blocks for both node and refund transactions
+   */
+  async checkTimelock(nodeId) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      const response = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: [nodeId]
+          }
+        },
+        includeParents: false,
+        network: NetworkToProto[this.config.getNetwork()]
+      });
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId
+        });
+      }
+      const isRootNode = !node.parentNodeId;
+      if (!node.nodeTx || node.nodeTx.length === 0) {
+        throw new ValidationError(
+          `Node transaction data is missing or empty for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "nodeTx",
+            value: node.nodeTx?.length || 0
+          }
+        );
+      }
+      if (!node.refundTx || node.refundTx.length === 0) {
+        throw new ValidationError(
+          `Refund transaction data is missing or empty for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "refundTx",
+            value: node.refundTx?.length || 0
+          }
+        );
+      }
+      let nodeTx, refundTx;
+      try {
+        nodeTx = getTxFromRawTxBytes(node.nodeTx);
+      } catch (error) {
+        throw new ValidationError(
+          `Failed to parse node transaction for ${isRootNode ? "root" : "non-root"} node: ${error instanceof Error ? error.message : String(error)}`,
+          {
+            field: "nodeTx",
+            value: node.nodeTx.length
+          }
+        );
+      }
+      try {
+        refundTx = getTxFromRawTxBytes(node.refundTx);
+      } catch (error) {
+        throw new ValidationError(
+          `Failed to parse refund transaction for ${isRootNode ? "root" : "non-root"} node: ${error instanceof Error ? error.message : String(error)}`,
+          {
+            field: "refundTx",
+            value: node.refundTx.length
+          }
+        );
+      }
+      const nodeInput = nodeTx.getInput(0);
+      if (!nodeInput) {
+        throw new ValidationError(
+          `Node transaction has no inputs for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "nodeInput",
+            value: nodeTx.inputsLength
+          }
+        );
+      }
+      if (!nodeInput.sequence) {
+        throw new ValidationError(
+          `Node transaction has no sequence for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "sequence",
+            value: nodeInput.sequence
+          }
+        );
+      }
+      const refundInput = refundTx.getInput(0);
+      if (!refundInput) {
+        throw new ValidationError(
+          `Refund transaction has no inputs for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "refundInput",
+            value: refundTx.inputsLength
+          }
+        );
+      }
+      if (!refundInput.sequence) {
+        throw new ValidationError(
+          `Refund transaction has no sequence for ${isRootNode ? "root" : "non-root"} node`,
+          {
+            field: "sequence",
+            value: refundInput.sequence
+          }
+        );
+      }
+      const nodeTimelock = nodeInput.sequence & 65535;
+      const refundTimelock = refundInput.sequence & 65535;
+      return {
+        nodeTimelock,
+        refundTimelock
+      };
+    } catch (error) {
+      throw new NetworkError(
+        `Failed to check timelock for node ${nodeId}`,
+        {
+          method: "query_nodes"
+        },
+        error
+      );
+    }
+  }
+  /**
+   * Refresh the timelock of a specific node.
+   *
+   * @param {string} nodeId - The ID of the node to refresh
+   * @returns {Promise<void>} Promise that resolves when the timelock is refreshed
+   */
+  async testOnly_expireTimelock(nodeId) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      const response = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: [nodeId]
+          }
+        },
+        includeParents: true
+      });
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId
+        });
+      }
+      if (!node.parentNodeId) {
+        throw new ValidationError("Node has no parent", {
+          field: "parentNodeId",
+          value: node.parentNodeId
+        });
+      }
+      const parentNode = response.nodes[node.parentNodeId];
+      if (!parentNode) {
+        throw new ValidationError("Parent node not found", {
+          field: "parentNodeId",
+          value: node.parentNodeId
+        });
+      }
+      const signingPubKey = await this.config.signer.generatePublicKey(
+        sha25613(node.id)
+      );
+      const result = await this.transferService.refreshTimelockNodes(
+        [node],
+        parentNode,
+        signingPubKey
+      );
+      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === node.id);
+      if (leafIndex !== -1 && result.nodes.length > 0) {
+        const newNode = result.nodes[0];
+        if (newNode) {
+          this.leaves[leafIndex] = newNode;
+        }
+      }
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to refresh timelock",
+        {
+          method: "refresh_timelock"
+        },
+        error
+      );
+    }
+  }
+  /**
+   * Refresh the timelock of a specific node's refund transaction only.
+   *
+   * @param {string} nodeId - The ID of the node whose refund transaction to refresh
+   * @returns {Promise<void>} Promise that resolves when the refund timelock is refreshed
+   */
+  async testOnly_expireTimelockRefundTx(nodeId) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      const response = await sparkClient.query_nodes({
+        source: {
+          $case: "nodeIds",
+          nodeIds: {
+            nodeIds: [nodeId]
+          }
+        },
+        includeParents: false
+      });
+      const node = response.nodes[nodeId];
+      if (!node) {
+        throw new ValidationError("Node not found", {
+          field: "nodeId",
+          value: nodeId
+        });
+      }
+      const signingPubKey = await this.config.signer.generatePublicKey(
+        sha25613(node.id)
+      );
+      const result = await this.transferService.refreshTimelockRefundTx(
+        node,
+        signingPubKey
+      );
+      const leafIndex = this.leaves.findIndex((leaf) => leaf.id === node.id);
+      if (leafIndex !== -1 && result.nodes.length > 0) {
+        const newNode = result.nodes[0];
+        if (newNode) {
+          this.leaves[leafIndex] = newNode;
+        }
+      }
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to refresh refund timelock",
+        {
+          method: "refresh_timelock_refund_tx"
+        },
+        error
+      );
+    }
+  }
   cleanup() {
     if (this.claimTransfersInterval) {
       clearInterval(this.claimTransfersInterval);
@@ -27775,9 +28331,471 @@ async function getLatestDepositTxId(address2) {
   }
   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/unilateral-exit.ts
+import { bytesToHex as bytesToHex13, hexToBytes as hexToBytes14 } from "@noble/curves/abstract/utils";
+import { ripemd160 } from "@noble/hashes/legacy";
+import { sha256 as sha25614 } from "@noble/hashes/sha2";
+import * as btc5 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(hexToBytes14(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 = bytesToHex13(chainNode.nodeTx);
+      transactions.push(nodeTx);
+      if (chainNode.id === node.id) {
+        const refundTx = bytesToHex13(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 = hexToBytes14(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 = bytesToHex13(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 = bytesToHex13(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 = btc5.Transaction.fromPSBT(hexToBytes14(nodeFeeBumpPsbt));
+      var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
+      var feeBumpOutPubKey = null;
+      for (const usedUtxo of usedUtxos) {
+        if (feeBumpOut && bytesToHex13(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: bytesToHex13(feeBumpOut.script),
+          publicKey: feeBumpOutPubKey
+        });
+      const finalNodeTx = correctedParentTx || nodeTxHex;
+      txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
+      if (chainNode.id === node.id) {
+        let refundTxHex = bytesToHex13(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 = bytesToHex13(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 = sha25614(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 btc5.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(hexToBytes14(fundingUtxo.publicKey));
+    const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
+    const providedScript = hexToBytes14(fundingUtxo.script);
+    if (bytesToHex13(scriptToUse) !== bytesToHex13(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 = bytesToHex13(builder.toPSBT());
+  } catch (error) {
+    throw new Error(`Failed to extract transaction: ${error}`);
+  }
+  return {
+    feeBumpPsbt: psbtHex,
+    usedUtxos: utxos,
+    correctedParentTx: correctedTxHex !== txHex ? correctedTxHex : void 0
+  };
+}
 export {
   AuthenticationError,
   ConfigurationError,
+  DEFAULT_FEE_SATS,
   ReactNativeSparkSigner as DefaultSparkSigner,
   InternalValidationError,
   LRC_WALLET_NETWORK,
@@ -27801,6 +28819,9 @@ export {
   collectResponses,
   computeTaprootKeyNoScript,
   computerLagrangeCoefficients,
+  constructFeeBumpTx,
+  constructUnilateralExitFeeBumpPackages,
+  constructUnilateralExitTxs,
   createRefundTx,
   createSigningCommitment,
   createSigningNonce,
@@ -27819,6 +28840,7 @@ export {
   getLatestDepositTxId,
   getNetwork,
   getNetworkFromAddress,
+  getNetworkFromString,
   getNextTransactionSequence,
   getP2TRAddressFromPkScript,
   getP2TRAddressFromPublicKey,
@@ -27834,7 +28856,10 @@ export {
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  isEphemeralAnchorOutput,
+  isTxBroadcast,
   lastKeyWithTarget,
+  maybeApplyFee,
   modInverse,
   proofOfPossessionMessageHashForDepositAddress,
   recoverSecret,