@buildonspark/spark-sdk 0.1.39 → 0.1.40

package/dist/index.cjs

@@ -1289,6 +1289,7 @@ var index_exports = {};
 __export(index_exports, {
   AuthenticationError: () => AuthenticationError,
   ConfigurationError: () => ConfigurationError,
+  DEFAULT_FEE_SATS: () => DEFAULT_FEE_SATS,
   InternalValidationError: () => InternalValidationError,
   LRC_WALLET_NETWORK: () => LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE: () => LRC_WALLET_NETWORK_TYPE,
@@ -1310,6 +1311,9 @@ __export(index_exports, {
   collectResponses: () => collectResponses,
   computeTaprootKeyNoScript: () => computeTaprootKeyNoScript,
   computerLagrangeCoefficients: () => computerLagrangeCoefficients,
+  constructFeeBumpTx: () => constructFeeBumpTx,
+  constructUnilateralExitFeeBumpPackages: () => constructUnilateralExitFeeBumpPackages,
+  constructUnilateralExitTxs: () => constructUnilateralExitTxs,
   createDummyTx: () => createDummyTx,
   createRefundTx: () => createRefundTx,
   createSigningCommitment: () => createSigningCommitment,
@@ -1329,6 +1333,7 @@ __export(index_exports, {
   getLatestDepositTxId: () => getLatestDepositTxId,
   getNetwork: () => getNetwork,
   getNetworkFromAddress: () => getNetworkFromAddress,
+  getNetworkFromString: () => getNetworkFromString,
   getNextTransactionSequence: () => getNextTransactionSequence,
   getP2TRAddressFromPkScript: () => getP2TRAddressFromPkScript,
   getP2TRAddressFromPublicKey: () => getP2TRAddressFromPublicKey,
@@ -1344,7 +1349,10 @@ __export(index_exports, {
   getTxFromRawTxHex: () => getTxFromRawTxHex,
   getTxId: () => getTxId,
   getTxIdNoReverse: () => getTxIdNoReverse,
+  isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
+  isTxBroadcast: () => isTxBroadcast,
   lastKeyWithTarget: () => lastKeyWithTarget,
+  maybeApplyFee: () => maybeApplyFee,
   modInverse: () => modInverse,
   proofOfPossessionMessageHashForDepositAddress: () => proofOfPossessionMessageHashForDepositAddress,
   recoverSecret: () => recoverSecret,
@@ -17017,11 +17025,9 @@ function decodeBytesToSigningCommitment(bytes2) {
 }
 
 // src/signer/signer.ts
-var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
-var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
 var import_secp256k16 = require("@bitcoinerlab/secp256k1");
+var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
 var import_sha22 = require("@noble/hashes/sha2");
-var import_lrc20_sdk3 = require("@buildonspark/lrc20-sdk");
 var sparkFrostModule = void 0;
 var getSparkFrostModule = async () => {
   if (isReactNative) {
@@ -17487,16 +17493,16 @@ var DefaultSparkSigner = class {
     }
     if (receipt) {
       const receiptPrivateKey = this.getReceiptPrivateKey(receipt);
-      const tweakedKeyPair = (0, import_lrc20_sdk3.fromPrivateKey)(import_buffer.Buffer.from(receiptPrivateKey));
+      const tweakedKeyPair = (0, import_lrc20_sdk.fromPrivateKey)(import_buffer.Buffer.from(receiptPrivateKey));
       psbt.signInput(input, tweakedKeyPair, sighashTypes);
       return psbt;
     }
-    const keypair = (0, import_lrc20_sdk3.fromPrivateKey)(import_buffer.Buffer.from(this.identityKey.privateKey));
+    const keypair = (0, import_lrc20_sdk.fromPrivateKey)(import_buffer.Buffer.from(this.identityKey.privateKey));
     psbt.signInput(input, keypair, sighashTypes);
     return psbt;
   }
   getReceiptPrivateKey(receipt) {
-    const pxh = import_lrc20_sdk2.Receipt.receiptHash(receipt);
+    const pxh = import_lrc20_sdk.Receipt.receiptHash(receipt);
     let innerKey = this.identityKey.publicKey;
     let privateKey = this.identityKey.privateKey;
     if (innerKey[0] === 3) {
@@ -17507,11 +17513,30 @@ var DefaultSparkSigner = class {
     const receiptProof = (0, import_secp256k16.privateAdd)(privateKey, pxhPubkey);
     return import_buffer.Buffer.from(receiptProof);
   }
+  signTransactionIndex(tx, index, publicKey) {
+    let privateKey;
+    if ((0, import_utils4.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.identityKey?.privateKey;
+    } else if ((0, import_utils4.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.depositKey?.privateKey;
+    } else {
+      privateKey = (0, import_utils4.hexToBytes)(
+        this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey)) ?? ""
+      );
+    }
+    if (!privateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+        value: (0, import_utils4.bytesToHex)(publicKey)
+      });
+    }
+    tx.signIdx(privateKey, index);
+  }
 };
 
 // src/utils/network.ts
 init_buffer();
-var import_lrc20_sdk4 = require("@buildonspark/lrc20-sdk");
+var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
 var btc = __toESM(require("@scure/btc-signer"), 1);
 var bitcoin = __toESM(require("bitcoinjs-lib"), 1);
 var Network2 = /* @__PURE__ */ ((Network5) => {
@@ -17545,11 +17570,11 @@ var LRC_WALLET_NETWORK = Object.freeze({
   [4 /* LOCAL */]: bitcoin.networks.regtest
 });
 var LRC_WALLET_NETWORK_TYPE = Object.freeze({
-  [0 /* MAINNET */]: import_lrc20_sdk4.NetworkType.MAINNET,
-  [1 /* TESTNET */]: import_lrc20_sdk4.NetworkType.TESTNET,
-  [2 /* SIGNET */]: import_lrc20_sdk4.NetworkType.TESTNET,
-  [3 /* REGTEST */]: import_lrc20_sdk4.NetworkType.REGTEST,
-  [4 /* LOCAL */]: import_lrc20_sdk4.NetworkType.LOCAL
+  [0 /* MAINNET */]: import_lrc20_sdk2.NetworkType.MAINNET,
+  [1 /* TESTNET */]: import_lrc20_sdk2.NetworkType.TESTNET,
+  [2 /* SIGNET */]: import_lrc20_sdk2.NetworkType.TESTNET,
+  [3 /* REGTEST */]: import_lrc20_sdk2.NetworkType.REGTEST,
+  [4 /* LOCAL */]: import_lrc20_sdk2.NetworkType.LOCAL
 });
 function getNetworkFromAddress(address2) {
   try {
@@ -17572,6 +17597,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/services/wallet-config.ts
 init_buffer();
@@ -19129,8 +19162,20 @@ function getTxIdNoReverse(tx) {
 init_buffer();
 var import_btc_signer = require("@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 import_btc_signer.Transaction({ allowUnknownOutputs: true });
+  const newRefundTx = new import_btc_signer.Transaction({
+    version: 3,
+    allowUnknownOutputs: true
+  });
   newRefundTx.addInput({
     ...nodeOutPoint,
     sequence
@@ -19159,7 +19204,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
@@ -20053,9 +20098,20 @@ var TransferService = class extends BaseTransferService {
       if (!input) {
         throw Error("Could not fetch tx input");
       }
-      const newTx = new import_btc_signer2.Transaction({ allowUnknownOutputs: true });
-      for (let j = 0; j < nodeTx.outputsLength; j++) {
-        newTx.addOutput(nodeTx.getOutput(j));
+      const newTx = new import_btc_signer2.Transaction({ 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;
@@ -20082,9 +20138,23 @@ var TransferService = class extends BaseTransferService {
       throw Error("leaf does not have refund tx");
     }
     const refundTx = getTxFromRawTxBytes(leaf?.refundTx);
-    const newRefundTx = new import_btc_signer2.Transaction({ allowUnknownOutputs: true });
-    for (let j = 0; j < refundTx.outputsLength; j++) {
-      newRefundTx.addOutput(refundTx.getOutput(j));
+    const newRefundTx = new import_btc_signer2.Transaction({
+      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) {
@@ -20193,10 +20263,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);
@@ -20207,9 +20278,20 @@ var TransferService = class extends BaseTransferService {
       index: 0
     };
     const { nextSequence: newNodeSequence } = getNextTransactionSequence(refundSequence);
-    const newNodeTx = new import_btc_signer2.Transaction({ allowUnknownOutputs: true });
+    const newNodeTx = new import_btc_signer2.Transaction({
+      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: (0, import_utils7.hexToBytes)(getTxId(newNodeTx)),
@@ -20223,11 +20305,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(),
@@ -20301,6 +20388,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 import_btc_signer2.Transaction({
+      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
@@ -20604,7 +20779,7 @@ var DepositService = class {
     depositTx,
     vout
   }) {
-    const rootTx = new import_btc_signer4.Transaction();
+    const rootTx = new import_btc_signer4.Transaction({ version: 3 });
     const output = depositTx.getOutput(vout);
     if (!output) {
       throw new ValidationError("Invalid deposit transaction output", {
@@ -20622,17 +20797,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 import_btc_signer4.Transaction();
+    const refundTx = new import_btc_signer4.Transaction({ version: 3 });
     const sequence = 1 << 30 | INITIAL_TIME_LOCK2;
     refundTx.addInput({
       txid: getTxId(rootTx),
@@ -20647,10 +20824,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()
     );
@@ -25158,7 +25336,7 @@ function isValidPublicKey(publicKey) {
 }
 
 // src/services/token-transactions.ts
-var MAX_TOKEN_OUTPUTS = 1e3;
+var MAX_TOKEN_OUTPUTS = 500;
 var TokenTransactionService = class {
   config;
   connectionManager;
@@ -25723,6 +25901,12 @@ var import_utils15 = require("@noble/curves/abstract/utils");
 var import_sha212 = require("@noble/hashes/sha2");
 var import_btc_signer5 = require("@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;
@@ -25921,7 +26105,7 @@ var TreeCreationService = class {
       refundTxSigningJob: void 0,
       children: []
     };
-    const tx = new import_btc_signer5.Transaction();
+    const tx = new import_btc_signer5.Transaction({ version: 3 });
     tx.addInput({
       txid: getTxId(parentTx),
       index: vout
@@ -25933,6 +26117,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();
@@ -25949,7 +26134,7 @@ var TreeCreationService = class {
       refundTxSigningJob: void 0,
       children: []
     };
-    const childTx = new import_btc_signer5.Transaction();
+    const childTx = new import_btc_signer5.Transaction({ version: 3 });
     childTx.addInput({
       txid: getTxId(tx),
       index: 0,
@@ -25958,6 +26143,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();
@@ -25968,7 +26154,7 @@ var TreeCreationService = class {
     };
     childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
     childCreationNode.nodeTxSigningJob = childSigningJob;
-    const refundTx = new import_btc_signer5.Transaction();
+    const refundTx = new import_btc_signer5.Transaction({ version: 3 });
     refundTx.addInput({
       txid: getTxId(childTx),
       index: 0,
@@ -25984,8 +26170,9 @@ var TreeCreationService = class {
     const refundPkScript = import_btc_signer5.OutScript.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,
@@ -26002,7 +26189,7 @@ var TreeCreationService = class {
     if (!parentTxOutput?.script || !parentTxOutput?.amount) {
       throw new Error("parentTxOutput is undefined");
     }
-    const rootNodeTx = new import_btc_signer5.Transaction();
+    const rootNodeTx = new import_btc_signer5.Transaction({ version: 3 });
     rootNodeTx.addInput({
       txid: getTxId(parentTx),
       index: vout
@@ -26017,10 +26204,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,
@@ -26171,7 +26358,7 @@ var TreeCreationService = class {
 };
 
 // src/spark-wallet/spark-wallet.ts
-var import_lrc20_sdk5 = require("@buildonspark/lrc20-sdk");
+var import_lrc20_sdk3 = require("@buildonspark/lrc20-sdk");
 var import_sha213 = require("@noble/hashes/sha2");
 var import_eventemitter3 = require("eventemitter3");
 
@@ -27080,7 +27267,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     }
     await this.initWalletFromSeed(seed, accountNumber);
     const network = this.config.getNetwork();
-    this.lrc20Wallet = await import_lrc20_sdk5.LRCWallet.create(
+    this.lrc20Wallet = await import_lrc20_sdk3.LRCWallet.create(
       LRC_WALLET_NETWORK[network],
       LRC_WALLET_NETWORK_TYPE[network],
       this.config.lrc20ApiConfig,
@@ -28964,6 +29151,112 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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 = import_btc_signer7.Transaction.fromRaw((0, import_utils20.hexToBytes)(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 ((0, import_utils20.bytesToHex)(script) === (0, import_utils20.bytesToHex)(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 ((0, import_utils20.bytesToHex)(script) === (0, import_utils20.bytesToHex)(identityScript)) {
+            return {
+              publicKey: identityPubKey,
+              keyType: "identity"
+            };
+          }
+          if ((0, import_utils20.bytesToHex)(script) === (0, import_utils20.bytesToHex)(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.
    *
@@ -28994,6 +29287,246 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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(
+        (0, import_sha213.sha256)(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(
+        (0, import_sha213.sha256)(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);
@@ -29088,10 +29621,473 @@ 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
+init_buffer();
+var import_utils21 = require("@noble/curves/abstract/utils");
+var import_legacy = require("@noble/hashes/legacy");
+var import_sha214 = require("@noble/hashes/sha2");
+var btc5 = __toESM(require("@scure/btc-signer"), 1);
+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((0, import_utils21.hexToBytes)(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 = (0, import_utils21.bytesToHex)(chainNode.nodeTx);
+      transactions.push(nodeTx);
+      if (chainNode.id === node.id) {
+        const refundTx = (0, import_utils21.bytesToHex)(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 = (0, import_utils21.hexToBytes)(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 = (0, import_utils21.bytesToHex)(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 = (0, import_utils21.bytesToHex)(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((0, import_utils21.hexToBytes)(nodeFeeBumpPsbt));
+      var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
+      var feeBumpOutPubKey = null;
+      for (const usedUtxo of usedUtxos) {
+        if (feeBumpOut && (0, import_utils21.bytesToHex)(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: (0, import_utils21.bytesToHex)(feeBumpOut.script),
+          publicKey: feeBumpOutPubKey
+        });
+      const finalNodeTx = correctedParentTx || nodeTxHex;
+      txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
+      if (chainNode.id === node.id) {
+        let refundTxHex = (0, import_utils21.bytesToHex)(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 = (0, import_utils21.bytesToHex)(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 = (0, import_sha214.sha256)(data);
+  return (0, import_legacy.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((0, import_utils21.hexToBytes)(fundingUtxo.publicKey));
+    const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
+    const providedScript = (0, import_utils21.hexToBytes)(fundingUtxo.script);
+    if ((0, import_utils21.bytesToHex)(scriptToUse) !== (0, import_utils21.bytesToHex)(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 = (0, import_utils21.bytesToHex)(builder.toPSBT());
+  } catch (error) {
+    throw new Error(`Failed to extract transaction: ${error}`);
+  }
+  return {
+    feeBumpPsbt: psbtHex,
+    usedUtxos: utxos,
+    correctedParentTx: correctedTxHex !== txHex ? correctedTxHex : void 0
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthenticationError,
   ConfigurationError,
+  DEFAULT_FEE_SATS,
   InternalValidationError,
   LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE,
@@ -29113,6 +30109,9 @@ async function getLatestDepositTxId(address2) {
   collectResponses,
   computeTaprootKeyNoScript,
   computerLagrangeCoefficients,
+  constructFeeBumpTx,
+  constructUnilateralExitFeeBumpPackages,
+  constructUnilateralExitTxs,
   createDummyTx,
   createRefundTx,
   createSigningCommitment,
@@ -29132,6 +30131,7 @@ async function getLatestDepositTxId(address2) {
   getLatestDepositTxId,
   getNetwork,
   getNetworkFromAddress,
+  getNetworkFromString,
   getNextTransactionSequence,
   getP2TRAddressFromPkScript,
   getP2TRAddressFromPublicKey,
@@ -29147,7 +30147,10 @@ async function getLatestDepositTxId(address2) {
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  isEphemeralAnchorOutput,
+  isTxBroadcast,
   lastKeyWithTarget,
+  maybeApplyFee,
   modInverse,
   proofOfPossessionMessageHashForDepositAddress,
   recoverSecret,