@buildonspark/spark-sdk 0.2.3 → 0.2.5

package/dist/{chunk-PLLJIZC3.js → chunk-U7LRIWTF.js}

@@ -4,9 +4,10 @@ import {
 import {
   mapTransferToWalletTransfer,
   mapTreeNodeToWalletLeaf
-} from "./chunk-3SEOTO43.js";
+} from "./chunk-3SPMJMUX.js";
 import {
   BitcoinNetwork_default,
+  ClaimStaticDepositFromJson,
   ClaimStaticDepositRequestType_default,
   CoopExitFeeQuoteFromJson,
   CurrencyAmountFromJson,
@@ -22,7 +23,7 @@ import {
   LightningSendRequestFromJson,
   SparkCoopExitRequestStatus_default,
   TransferFromJson
-} from "./chunk-CDLETEDT.js";
+} from "./chunk-CQY5ML2A.js";
 import {
   Empty,
   SendLeafKeyTweaks,
@@ -577,7 +578,7 @@ import * as ecies from "eciesjs";
 import { isNode } from "@lightsparkdev/core";
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.3" : "unknown";
+var packageVersion = true ? "0.2.5" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -2911,10 +2912,23 @@ function getTxId(tx) {
 function getTxIdNoReverse(tx) {
   return bytesToHex4(sha2563(sha2563(tx.toBytes(true))));
 }
+function getTxEstimatedVbytesSizeByNumberOfInputsOutputs(numInputs, numOutputs) {
+  const TX_OVERHEAD = 10;
+  const IN_VBYTES = 150;
+  const OUT_VBYTES = 34;
+  return TX_OVERHEAD + numInputs * IN_VBYTES + numOutputs * OUT_VBYTES;
+}
 
 // src/utils/transaction.ts
 import { Transaction as Transaction2 } from "@scure/btc-signer";
+var INITIAL_TIMELOCK = 2e3;
+var TEST_UNILATERAL_TIMELOCK = 100;
 var TIME_LOCK_INTERVAL = 100;
+var DIRECT_TIMELOCK_OFFSET = 50;
+var INITIAL_SEQUENCE = 1 << 30 | INITIAL_TIMELOCK;
+var INITIAL_DIRECT_SEQUENCE = 1 << 30 | INITIAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
+var TEST_UNILATERAL_SEQUENCE = 1 << 30 | TEST_UNILATERAL_TIMELOCK;
+var TEST_UNILATERAL_DIRECT_SEQUENCE = 1 << 30 | TEST_UNILATERAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
 var ESTIMATED_TX_SIZE = 191;
 var DEFAULT_SATS_PER_VBYTE = 5;
 var DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
@@ -2924,29 +2938,270 @@ function maybeApplyFee(amount) {
   }
   return amount;
 }
-function createRefundTx(sequence, nodeOutPoint, amountSats, receivingPubkey, network) {
-  const newRefundTx = new Transaction2({
+function createRootTx(depositOutPoint, depositTxOut) {
+  const cpfpRootTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpRootTx.addInput(depositOutPoint);
+  cpfpRootTx.addOutput(depositTxOut);
+  cpfpRootTx.addOutput(getEphemeralAnchorOutput());
+  const directRootTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directRootTx.addInput(depositOutPoint);
+  directRootTx.addOutput({
+    script: depositTxOut.script,
+    amount: maybeApplyFee(depositTxOut.amount ?? 0n)
+  });
+  return [cpfpRootTx, directRootTx];
+}
+function createSplitTx(parentOutPoint, childTxOuts) {
+  const cpfpSplitTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpSplitTx.addInput(parentOutPoint);
+  for (const txOut of childTxOuts) {
+    cpfpSplitTx.addOutput(txOut);
+  }
+  cpfpSplitTx.addOutput(getEphemeralAnchorOutput());
+  const directSplitTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directSplitTx.addInput(parentOutPoint);
+  let totalOutputAmount = 0n;
+  for (const txOut of childTxOuts) {
+    totalOutputAmount += txOut.amount ?? 0n;
+  }
+  if (totalOutputAmount > BigInt(DEFAULT_FEE_SATS)) {
+    const feeRatio = Number(DEFAULT_FEE_SATS) / Number(totalOutputAmount);
+    for (const txOut of childTxOuts) {
+      const adjustedAmount = BigInt(
+        Math.floor(Number(txOut.amount ?? 0n) * (1 - feeRatio))
+      );
+      directSplitTx.addOutput({
+        script: txOut.script,
+        amount: adjustedAmount
+      });
+    }
+  } else {
+    for (const txOut of childTxOuts) {
+      directSplitTx.addOutput(txOut);
+    }
+  }
+  return [cpfpSplitTx, directSplitTx];
+}
+function createNodeTx({
+  txOut,
+  parentOutPoint,
+  applyFee,
+  includeAnchor
+}) {
+  const nodeTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  nodeTx.addInput(parentOutPoint);
+  if (applyFee) {
+    nodeTx.addOutput({
+      script: txOut.script,
+      amount: maybeApplyFee(txOut.amount ?? 0n)
+    });
+  } else {
+    nodeTx.addOutput(txOut);
+  }
+  if (includeAnchor) {
+    nodeTx.addOutput(getEphemeralAnchorOutput());
+  }
+  return nodeTx;
+}
+function createNodeTxs(txOut, txIn, directTxIn) {
+  const cpfpNodeTx = createNodeTx({
+    txOut,
+    parentOutPoint: txIn,
+    includeAnchor: true
+  });
+  let directNodeTx;
+  if (directTxIn) {
+    directNodeTx = createNodeTx({
+      txOut,
+      parentOutPoint: directTxIn,
+      includeAnchor: false,
+      applyFee: true
+    });
+  }
+  return { cpfpNodeTx, directNodeTx };
+}
+function createLeafNodeTx(sequence, directSequence, parentOutPoint, txOut, shouldCalculateFee) {
+  const cpfpLeafTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpLeafTx.addInput({
+    ...parentOutPoint,
+    sequence
+  });
+  cpfpLeafTx.addOutput(txOut);
+  cpfpLeafTx.addOutput(getEphemeralAnchorOutput());
+  const directLeafTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directLeafTx.addInput({
+    ...parentOutPoint,
+    sequence: directSequence
+  });
+  const amountSats = txOut.amount ?? 0n;
+  let outputAmount = amountSats;
+  if (shouldCalculateFee) {
+    outputAmount = maybeApplyFee(amountSats);
+  }
+  directLeafTx.addOutput({
+    script: txOut.script,
+    amount: outputAmount
+  });
+  return [cpfpLeafTx, directLeafTx];
+}
+function createRefundTx({
+  sequence,
+  input,
+  amountSats,
+  receivingPubkey,
+  network,
+  shouldCalculateFee,
+  includeAnchor
+}) {
+  const refundTx = new Transaction2({
     version: 3,
     allowUnknownOutputs: true
   });
-  newRefundTx.addInput({
-    ...nodeOutPoint,
+  refundTx.addInput({
+    ...input,
     sequence
   });
   const refundPkScript = getP2TRScriptFromPublicKey(receivingPubkey, network);
-  newRefundTx.addOutput({
+  let outputAmount = amountSats;
+  if (shouldCalculateFee) {
+    outputAmount = maybeApplyFee(amountSats);
+  }
+  refundTx.addOutput({
     script: refundPkScript,
+    amount: outputAmount
+  });
+  if (includeAnchor) {
+    refundTx.addOutput(getEphemeralAnchorOutput());
+  }
+  return refundTx;
+}
+function createRefundTxs({
+  sequence,
+  directSequence,
+  input,
+  directInput,
+  amountSats,
+  receivingPubkey,
+  network
+}) {
+  const cpfpRefundTx = createRefundTx({
+    sequence,
+    input,
+    amountSats,
+    receivingPubkey,
+    network,
+    shouldCalculateFee: false,
+    includeAnchor: true
+  });
+  let directRefundTx;
+  let directFromCpfpRefundTx;
+  if (directSequence && directInput) {
+    directRefundTx = createRefundTx({
+      sequence: directSequence,
+      input: directInput,
+      amountSats,
+      receivingPubkey,
+      network,
+      shouldCalculateFee: true,
+      includeAnchor: false
+    });
+    directFromCpfpRefundTx = createRefundTx({
+      sequence: directSequence,
+      input,
+      amountSats,
+      receivingPubkey,
+      network,
+      shouldCalculateFee: true,
+      includeAnchor: false
+    });
+  } else if (directInput && !directSequence) {
+    throw new ValidationError(
+      "directSequence must be provided if directInput is",
+      {
+        field: "directSequence",
+        value: directSequence
+      }
+    );
+  }
+  return { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx };
+}
+function createConnectorRefundTransactions(sequence, cpfpNodeOutPoint, directNodeOutPoint, connectorOutput, amountSats, receiverPubKey, network, shouldCalculateFee) {
+  const cpfpRefundTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpRefundTx.addInput({
+    ...cpfpNodeOutPoint,
+    sequence
+  });
+  cpfpRefundTx.addInput(connectorOutput);
+  const receiverScript = getP2TRScriptFromPublicKey(receiverPubKey, network);
+  cpfpRefundTx.addOutput({
+    script: receiverScript,
     amount: amountSats
   });
-  newRefundTx.addOutput(getEphemeralAnchorOutput());
-  return newRefundTx;
+  const directRefundTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directRefundTx.addInput({
+    ...directNodeOutPoint,
+    sequence
+  });
+  directRefundTx.addInput(connectorOutput);
+  let outputAmount = amountSats;
+  if (shouldCalculateFee) {
+    outputAmount = maybeApplyFee(amountSats);
+  }
+  directRefundTx.addOutput({
+    script: receiverScript,
+    amount: outputAmount
+  });
+  const directFromCpfpTx = new Transaction2({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  directFromCpfpTx.addInput({
+    ...cpfpNodeOutPoint,
+    sequence
+  });
+  directFromCpfpTx.addInput(connectorOutput);
+  directFromCpfpTx.addOutput({
+    script: receiverScript,
+    amount: outputAmount
+  });
+  return [cpfpRefundTx, directRefundTx, directFromCpfpTx];
 }
 function getCurrentTimelock(currSequence) {
   return (currSequence || 0) & 65535;
 }
 function getTransactionSequence(currSequence) {
   const timelock = getCurrentTimelock(currSequence);
-  return 1 << 30 | timelock;
+  return {
+    nextSequence: 1 << 30 | timelock,
+    nextDirectSequence: 1 << 30 | timelock + DIRECT_TIMELOCK_OFFSET
+  };
 }
 function checkIfValidSequence(currSequence) {
   const TIME_LOCK_ACTIVE = (currSequence || 0) & 2147483648;
@@ -2964,24 +3219,32 @@ function checkIfValidSequence(currSequence) {
     });
   }
 }
-function getNextTransactionSequence(currSequence, forRefresh) {
+function doesLeafNeedRefresh(currSequence, isNodeTx) {
   const currentTimelock = getCurrentTimelock(currSequence);
-  const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
-  if (forRefresh && nextTimelock <= 100 && currentTimelock > 0) {
-    return {
-      nextSequence: 1 << 30 | nextTimelock,
-      needRefresh: true
-    };
+  if (isNodeTx) {
+    return currentTimelock === 0;
   }
-  if (nextTimelock < 0) {
+  return currentTimelock <= 100;
+}
+function getNextTransactionSequence(currSequence, isNodeTx) {
+  const currentTimelock = getCurrentTimelock(currSequence);
+  const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
+  if (isNodeTx && nextTimelock < 0) {
     throw new ValidationError("timelock interval is less than 0", {
       field: "nextTimelock",
-      value: nextTimelock
+      value: nextTimelock,
+      expected: "Non-negative timelock interval"
+    });
+  } else if (!isNodeTx && nextTimelock <= 0) {
+    throw new ValidationError("timelock interval is less than or equal to 0", {
+      field: "nextTimelock",
+      value: nextTimelock,
+      expected: "Timelock greater than 0"
     });
   }
   return {
     nextSequence: 1 << 30 | nextTimelock,
-    needRefresh: nextTimelock <= 100
+    nextDirectSequence: 1 << 30 | nextTimelock + DIRECT_TIMELOCK_OFFSET
   };
 }
 function getEphemeralAnchorOutput() {
@@ -3033,10 +3296,8 @@ function proofOfPossessionMessageHashForDepositAddress(userPubkey, operatorPubke
 import { schnorr as schnorr3, secp256k1 as secp256k16 } from "@noble/curves/secp256k1";
 import { sha256 as sha2566 } from "@noble/hashes/sha2";
 import { hexToBytes as hexToBytes4 } from "@noble/hashes/utils";
-import * as btc3 from "@scure/btc-signer";
-import { p2tr as p2tr2, Transaction as Transaction3 } from "@scure/btc-signer";
+import { p2tr as p2tr2 } from "@scure/btc-signer";
 import { equalBytes as equalBytes3 } from "@scure/btc-signer/utils";
-var INITIAL_TIME_LOCK = 2e3;
 var DepositService = class {
   config;
   connectionManager;
@@ -3154,7 +3415,6 @@ var DepositService = class {
     depositTx,
     vout
   }) {
-    const rootTx = new Transaction3({ version: 3 });
     const output = depositTx.getOutput(vout);
     if (!output) {
       throw new ValidationError("Invalid deposit transaction output", {
@@ -3172,39 +3432,59 @@ var DepositService = class {
         expected: "Output with script and amount"
       });
     }
-    let outputAmount = amount;
-    rootTx.addInput({
-      txid: getTxId(depositTx),
+    const depositOutPoint = {
+      txid: hexToBytes4(getTxId(depositTx)),
       index: vout
-    });
-    rootTx.addOutput({
+    };
+    const depositTxOut = {
       script,
-      amount: outputAmount
-    });
-    rootTx.addOutput(getEphemeralAnchorOutput());
-    const rootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
-    const refundTx = new Transaction3({ version: 3 });
-    const sequence = 1 << 30 | INITIAL_TIME_LOCK;
-    refundTx.addInput({
-      txid: getTxId(rootTx),
-      index: 0,
-      sequence
-    });
+      amount
+    };
+    const [cpfpRootTx, directRootTx] = createRootTx(
+      depositOutPoint,
+      depositTxOut
+    );
+    const cpfpRootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directRootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpRootTxSighash = getSigHashFromTx(cpfpRootTx, 0, output);
+    const directRootTxSighash = getSigHashFromTx(directRootTx, 0, output);
     const signingPubKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
-    const refundP2trAddress = getP2TRAddressFromPublicKey(
-      signingPubKey,
-      this.config.getNetwork()
+    const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+      sequence: INITIAL_SEQUENCE,
+      directSequence: INITIAL_DIRECT_SEQUENCE,
+      input: { txid: hexToBytes4(getTxId(cpfpRootTx)), index: 0 },
+      directInput: { txid: hexToBytes4(getTxId(directRootTx)), index: 0 },
+      amountSats: amount,
+      receivingPubkey: signingPubKey,
+      network: this.config.getNetwork()
+    });
+    const cpfpRefundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directRefundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directFromCpfpRefundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpRefundTxSighash = getSigHashFromTx(
+      cpfpRefundTx,
+      0,
+      cpfpRootTx.getOutput(0)
+    );
+    if (!directRefundTx || !directFromCpfpRefundTx) {
+      throw new ValidationError(
+        "Expected direct refund transactions for tree creation",
+        {
+          field: "directRefundTx",
+          value: directRefundTx
+        }
+      );
+    }
+    const directRefundTxSighash = getSigHashFromTx(
+      directRefundTx,
+      0,
+      directRootTx.getOutput(0)
+    );
+    const directFromCpfpRefundTxSighash = getSigHashFromTx(
+      directFromCpfpRefundTx,
+      0,
+      cpfpRootTx.getOutput(0)
     );
-    const refundAddress = btc3.Address(getNetwork(this.config.getNetwork())).decode(refundP2trAddress);
-    const refundPkScript = btc3.OutScript.encode(refundAddress);
-    refundTx.addOutput({
-      script: refundPkScript,
-      amount: outputAmount
-    });
-    refundTx.addOutput(getEphemeralAnchorOutput());
-    const refundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const refundTxSighash = getSigHashFromTx(refundTx, 0, rootTx.getOutput(0));
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
@@ -3218,14 +3498,29 @@ var DepositService = class {
           network: this.config.getNetworkProto()
         },
         rootTxSigningJob: {
-          rawTx: rootTx.toBytes(),
+          rawTx: cpfpRootTx.toBytes(),
           signingPublicKey: signingPubKey,
-          signingNonceCommitment: rootNonceCommitment.commitment
+          signingNonceCommitment: cpfpRootNonceCommitment.commitment
         },
         refundTxSigningJob: {
-          rawTx: refundTx.toBytes(),
+          rawTx: cpfpRefundTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: cpfpRefundNonceCommitment.commitment
+        },
+        directRootTxSigningJob: {
+          rawTx: directRootTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: directRootNonceCommitment.commitment
+        },
+        directRefundTxSigningJob: {
+          rawTx: directRefundTx.toBytes(),
           signingPublicKey: signingPubKey,
-          signingNonceCommitment: refundNonceCommitment.commitment
+          signingNonceCommitment: directRefundNonceCommitment.commitment
+        },
+        directFromCpfpRefundTxSigningJob: {
+          rawTx: directFromCpfpRefundTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: directFromCpfpRefundNonceCommitment.commitment
         }
       });
     } catch (error) {
@@ -3264,6 +3559,30 @@ var DepositService = class {
         }
       );
     }
+    if (!treeResp.rootNodeSignatureShares.directNodeTxSigningResult?.signingNonceCommitments) {
+      throw new ValidationError(
+        "No direct node signing nonce commitments found in tree response",
+        {
+          field: "directNodeTxSigningResult.signingNonceCommitments"
+        }
+      );
+    }
+    if (!treeResp.rootNodeSignatureShares.directRefundTxSigningResult?.signingNonceCommitments) {
+      throw new ValidationError(
+        "No direct refund signing nonce commitments found in tree response",
+        {
+          field: "directRefundTxSigningResult.signingNonceCommitments"
+        }
+      );
+    }
+    if (!treeResp.rootNodeSignatureShares.directFromCpfpRefundTxSigningResult?.signingNonceCommitments) {
+      throw new ValidationError(
+        "No direct from CPFP refund signing nonce commitments found in tree response",
+        {
+          field: "directFromCpfpRefundTxSigningResult.signingNonceCommitments"
+        }
+      );
+    }
     if (!equalBytes3(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
@@ -3271,55 +3590,302 @@ var DepositService = class {
         expected: verifyingKey
       });
     }
-    const rootSignature = await this.config.signer.signFrost({
-      message: rootTxSighash,
+    const cpfpRootSignature = await this.config.signer.signFrost({
+      message: cpfpRootTxSighash,
       publicKey: signingPubKey,
       keyDerivation,
       verifyingKey,
-      selfCommitment: rootNonceCommitment,
+      selfCommitment: cpfpRootNonceCommitment,
       statechainCommitments: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signingNonceCommitments,
       adaptorPubKey: new Uint8Array()
     });
-    const refundSignature = await this.config.signer.signFrost({
-      message: refundTxSighash,
+    const directRootSignature = await this.config.signer.signFrost({
+      message: directRootTxSighash,
       publicKey: signingPubKey,
       keyDerivation,
       verifyingKey,
-      selfCommitment: refundNonceCommitment,
+      selfCommitment: directRootNonceCommitment,
+      statechainCommitments: treeResp.rootNodeSignatureShares.directNodeTxSigningResult.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const cpfpRefundSignature = await this.config.signer.signFrost({
+      message: cpfpRefundTxSighash,
+      publicKey: signingPubKey,
+      keyDerivation,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      selfCommitment: cpfpRefundNonceCommitment,
       statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
       adaptorPubKey: new Uint8Array()
     });
-    const rootAggregate = await this.config.signer.aggregateFrost({
-      message: rootTxSighash,
+    const directRefundSignature = await this.config.signer.signFrost({
+      message: directRefundTxSighash,
+      publicKey: signingPubKey,
+      keyDerivation,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      selfCommitment: directRefundNonceCommitment,
+      statechainCommitments: treeResp.rootNodeSignatureShares.directRefundTxSigningResult.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const directFromCpfpRefundSignature = await this.config.signer.signFrost({
+      message: directFromCpfpRefundTxSighash,
+      publicKey: signingPubKey,
+      keyDerivation,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      selfCommitment: directFromCpfpRefundNonceCommitment,
+      statechainCommitments: treeResp.rootNodeSignatureShares.directFromCpfpRefundTxSigningResult.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const cpfpRootAggregate = await this.config.signer.aggregateFrost({
+      message: cpfpRootTxSighash,
       statechainSignatures: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signatureShares,
       statechainPublicKeys: treeResp.rootNodeSignatureShares.nodeTxSigningResult.publicKeys,
       verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
       statechainCommitments: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signingNonceCommitments,
-      selfCommitment: rootNonceCommitment,
+      selfCommitment: cpfpRootNonceCommitment,
       publicKey: signingPubKey,
-      selfSignature: rootSignature,
+      selfSignature: cpfpRootSignature,
       adaptorPubKey: new Uint8Array()
     });
-    const refundAggregate = await this.config.signer.aggregateFrost({
-      message: refundTxSighash,
+    const directRootAggregate = await this.config.signer.aggregateFrost({
+      message: directRootTxSighash,
+      statechainSignatures: treeResp.rootNodeSignatureShares.directNodeTxSigningResult.signatureShares,
+      statechainPublicKeys: treeResp.rootNodeSignatureShares.directNodeTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments: treeResp.rootNodeSignatureShares.directNodeTxSigningResult.signingNonceCommitments,
+      selfCommitment: directRootNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: directRootSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    const cpfpRefundAggregate = await this.config.signer.aggregateFrost({
+      message: cpfpRefundTxSighash,
       statechainSignatures: treeResp.rootNodeSignatureShares.refundTxSigningResult.signatureShares,
       statechainPublicKeys: treeResp.rootNodeSignatureShares.refundTxSigningResult.publicKeys,
       verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
       statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
-      selfCommitment: refundNonceCommitment,
+      selfCommitment: cpfpRefundNonceCommitment,
       publicKey: signingPubKey,
-      selfSignature: refundSignature,
+      selfSignature: cpfpRefundSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    const directRefundAggregate = await this.config.signer.aggregateFrost({
+      message: directRefundTxSighash,
+      statechainSignatures: treeResp.rootNodeSignatureShares.directRefundTxSigningResult.signatureShares,
+      statechainPublicKeys: treeResp.rootNodeSignatureShares.directRefundTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments: treeResp.rootNodeSignatureShares.directRefundTxSigningResult.signingNonceCommitments,
+      selfCommitment: directRefundNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: directRefundSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    const directFromCpfpRefundAggregate = await this.config.signer.aggregateFrost({
+      message: directFromCpfpRefundTxSighash,
+      statechainSignatures: treeResp.rootNodeSignatureShares.directFromCpfpRefundTxSigningResult.signatureShares,
+      statechainPublicKeys: treeResp.rootNodeSignatureShares.directFromCpfpRefundTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments: treeResp.rootNodeSignatureShares.directFromCpfpRefundTxSigningResult.signingNonceCommitments,
+      selfCommitment: directFromCpfpRefundNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: directFromCpfpRefundSignature,
       adaptorPubKey: new Uint8Array()
     });
     let finalizeResp;
     try {
-      finalizeResp = await sparkClient.finalize_node_signatures({
+      finalizeResp = await sparkClient.finalize_node_signatures_v2({
         intent: 0 /* CREATION */,
         nodeSignatures: [
           {
             nodeId: treeResp.rootNodeSignatureShares.nodeId,
-            nodeTxSignature: rootAggregate,
-            refundTxSignature: refundAggregate
+            nodeTxSignature: cpfpRootAggregate,
+            refundTxSignature: cpfpRefundAggregate,
+            directNodeTxSignature: directRootAggregate,
+            directRefundTxSignature: directRefundAggregate,
+            directFromCpfpRefundTxSignature: directFromCpfpRefundAggregate
+          }
+        ]
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to finalize node signatures",
+        {
+          operation: "finalize_node_signatures",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+    return finalizeResp;
+  }
+  /**
+   * @deprecated
+   * Use createTreeRoot instead.
+   * This is currently only used to test backwards compatibility.
+   */
+  async createTreeWithoutDirectTx({
+    keyDerivation,
+    verifyingKey,
+    depositTx,
+    vout
+  }) {
+    const output = depositTx.getOutput(vout);
+    if (!output) {
+      throw new ValidationError("Invalid deposit transaction output", {
+        field: "vout",
+        value: vout,
+        expected: "Valid output index"
+      });
+    }
+    const script = output.script;
+    const amount = output.amount;
+    if (!script || !amount) {
+      throw new ValidationError("No script or amount found in deposit tx", {
+        field: "output",
+        value: output,
+        expected: "Output with script and amount"
+      });
+    }
+    const depositOutPoint = {
+      txid: hexToBytes4(getTxId(depositTx)),
+      index: vout
+    };
+    const depositTxOut = {
+      script,
+      amount
+    };
+    const [cpfpRootTx, _] = createRootTx(depositOutPoint, depositTxOut);
+    const cpfpRootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpRootTxSighash = getSigHashFromTx(cpfpRootTx, 0, output);
+    const signingPubKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
+    const { cpfpRefundTx } = createRefundTxs({
+      sequence: INITIAL_SEQUENCE,
+      input: { txid: hexToBytes4(getTxId(cpfpRootTx)), index: 0 },
+      amountSats: amount,
+      receivingPubkey: signingPubKey,
+      network: this.config.getNetwork()
+    });
+    const cpfpRefundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpRefundTxSighash = getSigHashFromTx(
+      cpfpRefundTx,
+      0,
+      cpfpRootTx.getOutput(0)
+    );
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let treeResp;
+    try {
+      treeResp = await sparkClient.start_deposit_tree_creation({
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        onChainUtxo: {
+          vout,
+          rawTx: depositTx.toBytes(true),
+          network: this.config.getNetworkProto()
+        },
+        rootTxSigningJob: {
+          rawTx: cpfpRootTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: cpfpRootNonceCommitment.commitment
+        },
+        refundTxSigningJob: {
+          rawTx: cpfpRefundTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: cpfpRefundNonceCommitment.commitment
+        }
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to start deposit tree creation",
+        {
+          operation: "start_deposit_tree_creation",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+    if (!treeResp.rootNodeSignatureShares?.verifyingKey) {
+      throw new ValidationError("No verifying key found in tree response", {
+        field: "verifyingKey",
+        value: treeResp.rootNodeSignatureShares,
+        expected: "Non-null verifying key"
+      });
+    }
+    if (!treeResp.rootNodeSignatureShares.nodeTxSigningResult?.signingNonceCommitments) {
+      throw new ValidationError(
+        "No signing nonce commitments found in tree response",
+        {
+          field: "nodeTxSigningResult.signingNonceCommitments",
+          value: treeResp.rootNodeSignatureShares.nodeTxSigningResult,
+          expected: "Non-null signing nonce commitments"
+        }
+      );
+    }
+    if (!treeResp.rootNodeSignatureShares.refundTxSigningResult?.signingNonceCommitments) {
+      throw new ValidationError(
+        "No signing nonce commitments found in tree response",
+        {
+          field: "refundTxSigningResult.signingNonceCommitments"
+        }
+      );
+    }
+    if (!equalBytes3(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+      throw new ValidationError("Verifying key mismatch", {
+        field: "verifyingKey",
+        value: treeResp.rootNodeSignatureShares.verifyingKey,
+        expected: verifyingKey
+      });
+    }
+    const cpfpRootSignature = await this.config.signer.signFrost({
+      message: cpfpRootTxSighash,
+      publicKey: signingPubKey,
+      keyDerivation,
+      verifyingKey,
+      selfCommitment: cpfpRootNonceCommitment,
+      statechainCommitments: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const cpfpRefundSignature = await this.config.signer.signFrost({
+      message: cpfpRefundTxSighash,
+      publicKey: signingPubKey,
+      keyDerivation,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      selfCommitment: cpfpRefundNonceCommitment,
+      statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const cpfpRootAggregate = await this.config.signer.aggregateFrost({
+      message: cpfpRootTxSighash,
+      statechainSignatures: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signatureShares,
+      statechainPublicKeys: treeResp.rootNodeSignatureShares.nodeTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signingNonceCommitments,
+      selfCommitment: cpfpRootNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: cpfpRootSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    const cpfpRefundAggregate = await this.config.signer.aggregateFrost({
+      message: cpfpRefundTxSighash,
+      statechainSignatures: treeResp.rootNodeSignatureShares.refundTxSigningResult.signatureShares,
+      statechainPublicKeys: treeResp.rootNodeSignatureShares.refundTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
+      selfCommitment: cpfpRefundNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: cpfpRefundSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    let finalizeResp;
+    try {
+      finalizeResp = await sparkClient.finalize_node_signatures_v2({
+        intent: 0 /* CREATION */,
+        nodeSignatures: [
+          {
+            nodeId: treeResp.rootNodeSignatureShares.nodeId,
+            nodeTxSignature: cpfpRootAggregate,
+            refundTxSignature: cpfpRefundAggregate
           }
         ]
       });
@@ -6021,13 +6587,24 @@ function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes
   const adaptorPrivateKey = bytesToNumberBE6(adaptorPrivateKeyBytes);
   const newS = mod(sBigInt + adaptorPrivateKey, secp256k110.CURVE.n);
   const newSig = new Uint8Array([...r, ...numberToBytesBE3(newS, 32)]);
-  if (schnorr4.verify(newSig, hash, pubkey)) {
-    return newSig;
+  try {
+    if (schnorr4.verify(newSig, hash, pubkey)) {
+      return newSig;
+    }
+  } catch (e) {
+    console.error("[applyAdaptorToSignature] Addition verification failed:", e);
   }
   const altS = mod(sBigInt - adaptorPrivateKey, secp256k110.CURVE.n);
   const altSig = new Uint8Array([...r, ...numberToBytesBE3(altS, 32)]);
-  if (schnorr4.verify(altSig, hash, pubkey)) {
-    return altSig;
+  try {
+    if (schnorr4.verify(altSig, hash, pubkey)) {
+      return altSig;
+    }
+  } catch (e) {
+    console.error(
+      "[applyAdaptorToSignature] Subtraction verification failed:",
+      e
+    );
   }
   throw new Error("Cannot apply adaptor to signature");
 }
@@ -6106,9 +6683,31 @@ function parseSignature(signature) {
 // src/tests/utils/test-faucet.ts
 import { bytesToHex as bytesToHex8, hexToBytes as hexToBytes7 } from "@noble/curves/abstract/utils";
 import { schnorr as schnorr5, secp256k1 as secp256k111 } from "@noble/curves/secp256k1";
-import * as btc4 from "@scure/btc-signer";
-import { Address as Address3, OutScript as OutScript3, SigHash as SigHash2, Transaction as Transaction4 } from "@scure/btc-signer";
+import * as btc3 from "@scure/btc-signer";
+import { Address as Address2, OutScript as OutScript2, SigHash as SigHash2, Transaction as Transaction4 } from "@scure/btc-signer";
 import { taprootTweakPrivKey as taprootTweakPrivKey2 } from "@scure/btc-signer/utils";
+
+// src/utils/fetch.ts
+var fetchImpl = typeof window !== "undefined" && window.fetch ? window.fetch.bind(window) : globalThis.fetch ? globalThis.fetch : null;
+var Headers = globalThis.Headers ?? null;
+var getFetch = () => {
+  if (!fetchImpl) {
+    throw new Error(
+      "Fetch implementation is not set. Please set it using setFetch()."
+    );
+  }
+  if (!Headers) {
+    throw new Error(
+      "Headers implementation is not set. Please set it using setFetch()."
+    );
+  }
+  return {
+    fetch: fetchImpl,
+    Headers
+  };
+};
+
+// src/tests/utils/test-faucet.ts
 var STATIC_FAUCET_KEY = hexToBytes7(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
 );
@@ -6252,7 +6851,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
   }
   async sendFaucetCoinToP2WPKHAddress(pubKey) {
     const sendToPubKeyTx = new Transaction4();
-    const p2wpkhAddress = btc4.p2wpkh(pubKey, getNetwork(4 /* LOCAL */)).address;
+    const p2wpkhAddress = btc3.p2wpkh(pubKey, getNetwork(4 /* LOCAL */)).address;
     if (!p2wpkhAddress) {
       throw new Error("Invalid P2WPKH address");
     }
@@ -6308,12 +6907,13 @@ var BitcoinFaucet = class _BitcoinFaucet {
   }
   async call(method, params) {
     try {
-      const response = await fetch(this.url, {
+      const { fetch: fetch2, Headers: Headers2 } = getFetch();
+      const response = await fetch2(this.url, {
         method: "POST",
-        headers: {
+        headers: new Headers2({
           "Content-Type": "application/json",
           Authorization: "Basic " + btoa(`${this.username}:${this.password}`)
-        },
+        }),
         body: JSON.stringify({
           jsonrpc: "1.0",
           id: "spark-js",
@@ -6368,10 +6968,10 @@ var BitcoinFaucet = class _BitcoinFaucet {
     const tx = new Transaction4();
     tx.addInput(coin.outpoint);
     const availableAmount = COIN_AMOUNT - FEE_AMOUNT;
-    const destinationAddress = Address3(getNetwork(4 /* LOCAL */)).decode(
+    const destinationAddress = Address2(getNetwork(4 /* LOCAL */)).decode(
       address2
     );
-    const destinationScript = OutScript3.encode(destinationAddress);
+    const destinationScript = OutScript2.encode(destinationAddress);
     tx.addOutput({
       script: destinationScript,
       amount
@@ -6418,7 +7018,7 @@ import {
 import { secp256k1 as secp256k114 } from "@noble/curves/secp256k1";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist as wordlist2 } from "@scure/bip39/wordlists/english";
-import { Address as Address5, OutScript as OutScript5, Transaction as Transaction8 } from "@scure/btc-signer";
+import { Address as Address4, OutScript as OutScript4, Transaction as Transaction8 } from "@scure/btc-signer";
 import { Mutex } from "async-mutex";
 import { uuidv7 as uuidv75, uuidv7obj } from "uuidv7";
 
@@ -6569,10 +7169,18 @@ var CompleteCoopExit = `
 var CompleteLeavesSwap = `
   mutation CompleteLeavesSwap(
     $adaptor_secret_key: String!
+    $direct_adaptor_secret_key: String!
+    $direct_from_cpfp_adaptor_secret_key: String!
     $user_outbound_transfer_external_id: UUID!
     $leaves_swap_request_id: ID!
   ) {
-    complete_leaves_swap(input: { adaptor_secret_key: $adaptor_secret_key, user_outbound_transfer_external_id: $user_outbound_transfer_external_id, leaves_swap_request_id: $leaves_swap_request_id }) {
+    complete_leaves_swap(input: { 
+      adaptor_secret_key: $adaptor_secret_key, 
+      direct_adaptor_secret_key: $direct_adaptor_secret_key,
+      direct_from_cpfp_adaptor_secret_key: $direct_from_cpfp_adaptor_secret_key,
+      user_outbound_transfer_external_id: $user_outbound_transfer_external_id, 
+      leaves_swap_request_id: $leaves_swap_request_id 
+    }) {
       request {
         ...LeavesSwapRequestFragment
       }
@@ -6695,6 +7303,8 @@ var RequestLightningSend = `
 var RequestSwapLeaves = `
   mutation RequestSwapLeaves(
     $adaptor_pubkey: PublicKey!
+    $direct_adaptor_pubkey: PublicKey
+    $direct_from_cpfp_adaptor_pubkey: PublicKey
     $total_amount_sats: Long!
     $target_amount_sats: Long!
     $fee_sats: Long!
@@ -6704,6 +7314,8 @@ var RequestSwapLeaves = `
   ) {
     request_leaves_swap(input: {
       adaptor_pubkey: $adaptor_pubkey
+      direct_adaptor_pubkey: $direct_adaptor_pubkey
+      direct_from_cpfp_adaptor_pubkey: $direct_from_cpfp_adaptor_pubkey
       total_amount_sats: $total_amount_sats
       target_amount_sats: $target_amount_sats
       fee_sats: $fee_sats
@@ -6982,14 +7594,18 @@ var LightningSendFeeEstimate = `
   ${FRAGMENT13}
 `;
 
-// src/graphql/queries/Transfer.ts
-var GetTransfer = `
-  query Transfer($transfer_spark_id: UUID!) {
-    transfer(transfer_spark_id: $transfer_spark_id) {
+// src/graphql/queries/Transfers.ts
+var GetTransfers = `
+  query Transfers($transfer_spark_ids: [UUID!]!) {
+    transfers(transfer_spark_ids: $transfer_spark_ids) {
       ...TransferFragment
+      transfer_user_request: user_request {
+        ...UserRequestFragment
+      }
     }
   }
   ${FRAGMENT}
+  ${FRAGMENT6}
 `;
 
 // src/graphql/queries/UserRequest.ts
@@ -7194,6 +7810,8 @@ var SspClient = class {
   }
   async requestLeaveSwap({
     adaptorPubkey,
+    directAdaptorPubkey,
+    directFromCpfpAdaptorPubkey,
     totalAmountSats,
     targetAmountSats,
     feeSats,
@@ -7205,6 +7823,8 @@ var SspClient = class {
       queryPayload: RequestSwapLeaves,
       variables: {
         adaptor_pubkey: adaptorPubkey,
+        direct_adaptor_pubkey: directAdaptorPubkey,
+        direct_from_cpfp_adaptor_pubkey: directFromCpfpAdaptorPubkey,
         total_amount_sats: totalAmountSats,
         target_amount_sats: targetAmountSats,
         fee_sats: feeSats,
@@ -7223,6 +7843,8 @@ var SspClient = class {
   }
   async completeLeaveSwap({
     adaptorSecretKey,
+    directAdaptorSecretKey,
+    directFromCpfpAdaptorSecretKey,
     userOutboundTransferExternalId,
     leavesSwapRequestId
   }) {
@@ -7230,6 +7852,8 @@ var SspClient = class {
       queryPayload: CompleteLeavesSwap,
       variables: {
         adaptor_secret_key: adaptorSecretKey,
+        direct_adaptor_secret_key: directAdaptorSecretKey,
+        direct_from_cpfp_adaptor_secret_key: directFromCpfpAdaptorSecretKey,
         user_outbound_transfer_external_id: userOutboundTransferExternalId,
         leaves_swap_request_id: leavesSwapRequestId
       },
@@ -7337,14 +7961,47 @@ var SspClient = class {
       }
     });
   }
-  async getTransfer(id) {
+  async getTransfers(ids) {
     return await this.executeRawQuery({
-      queryPayload: GetTransfer,
+      queryPayload: GetTransfers,
       variables: {
-        transfer_spark_id: id
+        transfer_spark_ids: ids
       },
       constructObject: (response) => {
-        return TransferFromJson(response.transfer);
+        return response.transfers.map((transfer) => {
+          const transferObj = TransferFromJson(
+            transfer
+          );
+          switch (transfer.transfer_user_request.__typename) {
+            case "ClaimStaticDeposit":
+              transferObj.userRequest = ClaimStaticDepositFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+            case "CoopExitRequest":
+              transferObj.userRequest = CoopExitRequestFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+            case "LeavesSwapRequest":
+              transferObj.userRequest = LeavesSwapRequestFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+            case "LightningReceiveRequest":
+              transferObj.userRequest = LightningReceiveRequestFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+            case "LightningSendRequest":
+              transferObj.userRequest = LightningSendRequestFromJson(
+                transfer.transfer_user_request
+              );
+              break;
+          }
+          const { userRequestId, ...rest } = transferObj;
+          return rest;
+        });
       }
     });
   }
@@ -7497,11 +8154,7 @@ import { sha256 as sha2569 } from "@noble/hashes/sha2";
 import { Transaction as Transaction5 } from "@scure/btc-signer";
 import * as ecies2 from "eciesjs";
 import { uuidv7 as uuidv72 } from "uuidv7";
-var INITIAL_TIME_LOCK2 = 2e3;
 var DEFAULT_EXPIRY_TIME = 10 * 60 * 1e3;
-function initialSequence() {
-  return 1 << 30 | INITIAL_TIME_LOCK2;
-}
 function getSigningJobProto(signingJob) {
   return {
     signingPublicKey: signingJob.signingPublicKey,
@@ -7518,12 +8171,14 @@ var BaseTransferService = class {
     this.connectionManager = connectionManager;
     this.signingService = signingService;
   }
-  async sendTransferTweakKey(transfer, leaves, refundSignatureMap) {
+  async sendTransferTweakKey(transfer, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
     const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
       transfer.id,
       transfer.receiverIdentityPublicKey,
       leaves,
-      refundSignatureMap
+      cpfpRefundSignatureMap,
+      directRefundSignatureMap,
+      directFromCpfpRefundSignatureMap
     );
     let updatedTransfer;
     const coordinatorOperator = this.config.getSigningOperators()[this.config.getCoordinatorIdentifier()];
@@ -7561,13 +8216,26 @@ var BaseTransferService = class {
     }
     return updatedTransfer;
   }
-  async deliverTransferPackage(transfer, leaves, refundSignatureMap) {
+  async deliverTransferPackage(transfer, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
     const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
       transfer.id,
       transfer.receiverIdentityPublicKey,
       leaves,
-      refundSignatureMap
+      cpfpRefundSignatureMap,
+      directRefundSignatureMap,
+      directFromCpfpRefundSignatureMap
     );
+    for (const [key, operator] of Object.entries(
+      this.config.getSigningOperators()
+    )) {
+      const tweaks = keyTweakInputMap.get(key);
+      if (!tweaks) {
+        throw new ValidationError("No tweaks for operator", {
+          field: "operator",
+          value: key
+        });
+      }
+    }
     const transferPackage = await this.prepareTransferPackage(
       transfer.id,
       keyTweakInputMap,
@@ -7593,6 +8261,8 @@ var BaseTransferService = class {
       transferID,
       receiverIdentityPubkey,
       leaves,
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
       /* @__PURE__ */ new Map()
     );
     const transferPackage = await this.prepareTransferPackage(
@@ -7606,7 +8276,7 @@ var BaseTransferService = class {
     );
     let response;
     try {
-      response = await sparkClient.start_transfer({
+      response = await sparkClient.start_transfer_v2({
         transferId: transferID,
         ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
         receiverIdentityPublicKey: receiverIdentityPubkey,
@@ -7635,12 +8305,22 @@ var BaseTransferService = class {
       nodes.push(leaf.leaf.id);
     }
     const signingCommitments = await sparkClient.get_signing_commitments({
-      nodeIds: nodes
+      nodeIds: nodes,
+      count: 3
     });
-    const leafSigningJobs = await this.signingService.signRefunds(
+    const {
+      cpfpLeafSigningJobs,
+      directLeafSigningJobs,
+      directFromCpfpLeafSigningJobs
+    } = await this.signingService.signRefunds(
       leaves,
-      signingCommitments.signingCommitments,
-      receiverIdentityPubkey
+      receiverIdentityPubkey,
+      signingCommitments.signingCommitments.slice(0, leaves.length),
+      signingCommitments.signingCommitments.slice(
+        leaves.length,
+        2 * leaves.length
+      ),
+      signingCommitments.signingCommitments.slice(2 * leaves.length)
     );
     const encryptedKeyTweaks = {};
     for (const [key, value] of keyTweakInputMap) {
@@ -7660,12 +8340,11 @@ var BaseTransferService = class {
       encryptedKeyTweaks[key] = Uint8Array.from(encryptedProto);
     }
     const transferPackage = {
-      leavesToSend: leafSigningJobs,
+      leavesToSend: cpfpLeafSigningJobs,
       keyTweakPackage: encryptedKeyTweaks,
       userSignature: new Uint8Array(),
-      // TODO: Add direct refund signature
-      directLeavesToSend: [],
-      directFromCpfpLeavesToSend: []
+      directLeavesToSend: directLeafSigningJobs,
+      directFromCpfpLeavesToSend: directFromCpfpLeafSigningJobs
     };
     const transferPackageSigningPayload = getTransferPackageSigningPayload(
       transferID,
@@ -7725,7 +8404,7 @@ var BaseTransferService = class {
     }
     return updatedTransfer;
   }
-  async signRefunds(leafDataMap, operatorSigningResults, adaptorPubKey) {
+  async signRefunds(leafDataMap, operatorSigningResults, cpfpAdaptorPubKey, directAdaptorPubKey, directFromCpfpAdaptorPubKey) {
     const nodeSignatures = [];
     for (const operatorSigningResult of operatorSigningResults) {
       const leafData = leafDataMap.get(operatorSigningResult.leafId);
@@ -7740,54 +8419,120 @@ var BaseTransferService = class {
           `Output not found for leaf ${operatorSigningResult.leafId}`
         );
       }
-      const refundTxSighash = getSigHashFromTx(leafData.refundTx, 0, txOutput);
+      const cpfpRefundTxSighash = getSigHashFromTx(
+        leafData.refundTx,
+        0,
+        txOutput
+      );
       const publicKey = await this.config.signer.getPublicKeyFromDerivation(
         leafData.keyDerivation
       );
-      const userSignature = await this.config.signer.signFrost({
-        message: refundTxSighash,
+      const cpfpUserSignature = await this.config.signer.signFrost({
+        message: cpfpRefundTxSighash,
         publicKey,
         keyDerivation: leafData.keyDerivation,
         selfCommitment: leafData.signingNonceCommitment,
         statechainCommitments: operatorSigningResult.refundTxSigningResult?.signingNonceCommitments,
-        adaptorPubKey,
+        adaptorPubKey: cpfpAdaptorPubKey,
         verifyingKey: operatorSigningResult.verifyingKey
       });
-      const refundAggregate = await this.config.signer.aggregateFrost({
-        message: refundTxSighash,
+      const cpfpRefundAggregate = await this.config.signer.aggregateFrost({
+        message: cpfpRefundTxSighash,
         statechainSignatures: operatorSigningResult.refundTxSigningResult?.signatureShares,
         statechainPublicKeys: operatorSigningResult.refundTxSigningResult?.publicKeys,
         verifyingKey: operatorSigningResult.verifyingKey,
         statechainCommitments: operatorSigningResult.refundTxSigningResult?.signingNonceCommitments,
         selfCommitment: leafData.signingNonceCommitment,
         publicKey,
-        selfSignature: userSignature,
-        adaptorPubKey
-      });
+        selfSignature: cpfpUserSignature,
+        adaptorPubKey: cpfpAdaptorPubKey
+      });
+      let directRefundAggregate;
+      let directFromCpfpRefundAggregate;
+      if (leafData.directTx) {
+        const directTxOutput = leafData.directTx.getOutput(0);
+        if (leafData.directRefundTx) {
+          const directRefundTxSighash = getSigHashFromTx(
+            leafData.directRefundTx,
+            0,
+            directTxOutput
+          );
+          const directUserSignature = await this.config.signer.signFrost({
+            message: directRefundTxSighash,
+            publicKey,
+            keyDerivation: leafData.keyDerivation,
+            selfCommitment: leafData.directSigningNonceCommitment,
+            statechainCommitments: operatorSigningResult.directRefundTxSigningResult?.signingNonceCommitments,
+            adaptorPubKey: directAdaptorPubKey,
+            verifyingKey: operatorSigningResult.verifyingKey
+          });
+          directRefundAggregate = await this.config.signer.aggregateFrost({
+            message: directRefundTxSighash,
+            statechainSignatures: operatorSigningResult.directRefundTxSigningResult?.signatureShares,
+            statechainPublicKeys: operatorSigningResult.directRefundTxSigningResult?.publicKeys,
+            verifyingKey: operatorSigningResult.verifyingKey,
+            statechainCommitments: operatorSigningResult.directRefundTxSigningResult?.signingNonceCommitments,
+            selfCommitment: leafData.directSigningNonceCommitment,
+            publicKey,
+            selfSignature: directUserSignature,
+            adaptorPubKey: directAdaptorPubKey
+          });
+        }
+        if (leafData.directFromCpfpRefundTx) {
+          const directFromCpfpRefundTxSighash = getSigHashFromTx(
+            leafData.directFromCpfpRefundTx,
+            0,
+            txOutput
+          );
+          const directFromCpfpUserSignature = await this.config.signer.signFrost({
+            message: directFromCpfpRefundTxSighash,
+            publicKey,
+            keyDerivation: leafData.keyDerivation,
+            selfCommitment: leafData.directFromCpfpRefundSigningNonceCommitment,
+            statechainCommitments: operatorSigningResult.directFromCpfpRefundTxSigningResult?.signingNonceCommitments,
+            adaptorPubKey: directFromCpfpAdaptorPubKey,
+            verifyingKey: operatorSigningResult.verifyingKey
+          });
+          directFromCpfpRefundAggregate = await this.config.signer.aggregateFrost({
+            message: directFromCpfpRefundTxSighash,
+            statechainSignatures: operatorSigningResult.directFromCpfpRefundTxSigningResult?.signatureShares,
+            statechainPublicKeys: operatorSigningResult.directFromCpfpRefundTxSigningResult?.publicKeys,
+            verifyingKey: operatorSigningResult.verifyingKey,
+            statechainCommitments: operatorSigningResult.directFromCpfpRefundTxSigningResult?.signingNonceCommitments,
+            selfCommitment: leafData.directFromCpfpRefundSigningNonceCommitment,
+            publicKey,
+            selfSignature: directFromCpfpUserSignature,
+            adaptorPubKey: directFromCpfpAdaptorPubKey
+          });
+        }
+      }
       nodeSignatures.push({
         nodeId: operatorSigningResult.leafId,
-        refundTxSignature: refundAggregate,
         nodeTxSignature: new Uint8Array(),
-        // TODO: Add direct refund signature
         directNodeTxSignature: new Uint8Array(),
-        directRefundTxSignature: new Uint8Array(),
-        directFromCpfpRefundTxSignature: new Uint8Array()
+        refundTxSignature: cpfpRefundAggregate,
+        directRefundTxSignature: directRefundAggregate ?? new Uint8Array(),
+        directFromCpfpRefundTxSignature: directFromCpfpRefundAggregate ?? new Uint8Array()
       });
     }
     return nodeSignatures;
   }
-  async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, refundSignatureMap) {
+  async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
     const receiverEciesPubKey = ecies2.PublicKey.fromHex(
       bytesToHex10(receiverIdentityPubkey)
     );
     const leavesTweaksMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
-      const refundSignature = refundSignatureMap.get(leaf.leaf.id);
+      const cpfpRefundSignature = cpfpRefundSignatureMap.get(leaf.leaf.id);
+      const directRefundSignature = directRefundSignatureMap.get(leaf.leaf.id);
+      const directFromCpfpRefundSignature = directFromCpfpRefundSignatureMap.get(leaf.leaf.id);
       const leafTweaksMap = await this.prepareSingleSendTransferKeyTweak(
         transferID,
         leaf,
         receiverEciesPubKey,
-        refundSignature
+        cpfpRefundSignature,
+        directRefundSignature,
+        directFromCpfpRefundSignature
       );
       for (const [identifier, leafTweak] of leafTweaksMap) {
         leavesTweaksMap.set(identifier, [
@@ -7798,7 +8543,7 @@ var BaseTransferService = class {
     }
     return leavesTweaksMap;
   }
-  async prepareSingleSendTransferKeyTweak(transferID, leaf, receiverEciesPubKey, refundSignature) {
+  async prepareSingleSendTransferKeyTweak(transferID, leaf, receiverEciesPubKey, cpfpRefundSignature, directRefundSignature, directFromCpfpRefundSignature) {
     const signingOperators = this.config.getSigningOperators();
     const { shares, secretCipher } = await this.config.signer.subtractSplitAndEncrypt({
       first: leaf.keyDerivation,
@@ -7846,10 +8591,9 @@ var BaseTransferService = class {
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak),
         secretCipher,
         signature,
-        refundSignature: refundSignature ?? new Uint8Array(),
-        // TODO: Add direct refund signature
-        directRefundSignature: new Uint8Array(),
-        directFromCpfpRefundSignature: new Uint8Array()
+        refundSignature: cpfpRefundSignature ?? new Uint8Array(),
+        directRefundSignature: directRefundSignature ?? new Uint8Array(),
+        directFromCpfpRefundSignature: directFromCpfpRefundSignature ?? new Uint8Array()
       });
     }
     return leafTweaksMap;
@@ -7879,7 +8623,12 @@ var TransferService = class extends BaseTransferService {
    * Deprecated in v0.1.32
    */
   async sendTransfer(leaves, receiverIdentityPubkey) {
-    const { transfer, signatureMap } = await this.sendTransferSignRefund(
+    const {
+      transfer,
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap
+    } = await this.sendTransferSignRefund(
       leaves,
       receiverIdentityPubkey,
       new Date(Date.now() + DEFAULT_EXPIRY_TIME)
@@ -7887,7 +8636,9 @@ var TransferService = class extends BaseTransferService {
     const transferWithTweakedKeys = await this.sendTransferTweakKey(
       transfer,
       leaves,
-      signatureMap
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap
     );
     return transferWithTweakedKeys;
   }
@@ -7991,7 +8742,13 @@ var TransferService = class extends BaseTransferService {
     return transferResp.transfers[0];
   }
   async sendTransferSignRefund(leaves, receiverIdentityPubkey, expiryTime) {
-    const { transfer, signatureMap, leafDataMap } = await this.sendTransferSignRefundInternal(
+    const {
+      transfer,
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap,
+      leafDataMap
+    } = await this.sendTransferSignRefundInternal(
       leaves,
       receiverIdentityPubkey,
       expiryTime,
@@ -8000,11 +8757,19 @@ var TransferService = class extends BaseTransferService {
     return {
       transfer,
       signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap,
       leafDataMap
     };
   }
   async startSwapSignRefund(leaves, receiverIdentityPubkey, expiryTime) {
-    const { transfer, signatureMap, leafDataMap } = await this.sendTransferSignRefundInternal(
+    const {
+      transfer,
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap,
+      leafDataMap
+    } = await this.sendTransferSignRefundInternal(
       leaves,
       receiverIdentityPubkey,
       expiryTime,
@@ -8013,31 +8778,45 @@ var TransferService = class extends BaseTransferService {
     return {
       transfer,
       signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap,
       leafDataMap
     };
   }
-  async counterSwapSignRefund(leaves, receiverIdentityPubkey, expiryTime, adaptorPubKey) {
+  async counterSwapSignRefund(leaves, receiverIdentityPubkey, expiryTime, cpfpAdaptorPubKey, directAdaptorPubKey, directFromCpfpAdaptorPubKey) {
     return this.sendTransferSignRefundInternal(
       leaves,
       receiverIdentityPubkey,
       expiryTime,
       true,
-      adaptorPubKey
+      cpfpAdaptorPubKey,
+      directAdaptorPubKey,
+      directFromCpfpAdaptorPubKey
     );
   }
-  async sendTransferSignRefundInternal(leaves, receiverIdentityPubkey, expiryTime, forSwap, adaptorPubKey) {
+  async sendTransferSignRefundInternal(leaves, receiverIdentityPubkey, expiryTime, forSwap, cpfpAdaptorPubKey, directAdaptorPubKey, directFromCpfpAdaptorPubKey) {
     const transferId = uuidv72();
     const leafDataMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
       const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const directSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const directFromCpfpRefundSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
       const tx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const refundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      const directTx = leaf.leaf.directTx.length > 0 ? getTxFromRawTxBytes(leaf.leaf.directTx) : void 0;
+      const directRefundTx = leaf.leaf.directRefundTx.length > 0 ? getTxFromRawTxBytes(leaf.leaf.directRefundTx) : void 0;
+      const directFromCpfpRefundTx = leaf.leaf.directFromCpfpRefundTx.length > 0 ? getTxFromRawTxBytes(leaf.leaf.directFromCpfpRefundTx) : void 0;
       leafDataMap.set(leaf.leaf.id, {
         keyDerivation: leaf.keyDerivation,
         receivingPubkey: receiverIdentityPubkey,
         signingNonceCommitment,
+        directSigningNonceCommitment,
         tx,
+        directTx,
         refundTx,
+        directRefundTx,
+        directFromCpfpRefundTx,
+        directFromCpfpRefundSigningNonceCommitment,
         vout: leaf.leaf.vout
       });
     }
@@ -8050,8 +8829,8 @@ var TransferService = class extends BaseTransferService {
     );
     let response;
     try {
-      if (adaptorPubKey !== void 0) {
-        response = await sparkClient.counter_leaf_swap({
+      if (cpfpAdaptorPubKey !== void 0 || directAdaptorPubKey !== void 0 || directFromCpfpAdaptorPubKey !== void 0) {
+        response = await sparkClient.counter_leaf_swap_v2({
           transfer: {
             transferId,
             leavesToSend: signingJobs,
@@ -8060,10 +8839,12 @@ var TransferService = class extends BaseTransferService {
             expiryTime
           },
           swapId: uuidv72(),
-          adaptorPublicKey: adaptorPubKey || new Uint8Array()
+          adaptorPublicKey: cpfpAdaptorPubKey,
+          directAdaptorPublicKey: directAdaptorPubKey,
+          directFromCpfpAdaptorPublicKey: directFromCpfpAdaptorPubKey
         });
       } else if (forSwap) {
-        response = await sparkClient.start_leaf_swap({
+        response = await sparkClient.start_leaf_swap_v2({
           transferId,
           leavesToSend: signingJobs,
           ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
@@ -8071,7 +8852,7 @@ var TransferService = class extends BaseTransferService {
           expiryTime
         });
       } else {
-        response = await sparkClient.start_transfer({
+        response = await sparkClient.start_transfer_v2({
           transferId,
           leavesToSend: signingJobs,
           ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
@@ -8088,15 +8869,29 @@ var TransferService = class extends BaseTransferService {
     const signatures = await this.signRefunds(
       leafDataMap,
       response.signingResults,
-      adaptorPubKey
+      cpfpAdaptorPubKey,
+      directAdaptorPubKey,
+      directFromCpfpAdaptorPubKey
     );
-    const signatureMap = /* @__PURE__ */ new Map();
+    const cpfpSignatureMap = /* @__PURE__ */ new Map();
+    const directSignatureMap = /* @__PURE__ */ new Map();
+    const directFromCpfpSignatureMap = /* @__PURE__ */ new Map();
     for (const signature of signatures) {
-      signatureMap.set(signature.nodeId, signature.refundTxSignature);
+      cpfpSignatureMap.set(signature.nodeId, signature.refundTxSignature);
+      directSignatureMap.set(
+        signature.nodeId,
+        signature.directRefundTxSignature
+      );
+      directFromCpfpSignatureMap.set(
+        signature.nodeId,
+        signature.directFromCpfpRefundTxSignature
+      );
     }
     return {
       transfer: response.transfer,
-      signatureMap,
+      signatureMap: cpfpSignatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap,
       leafDataMap,
       signingResults: response.signingResults
     };
@@ -8109,38 +8904,68 @@ var TransferService = class extends BaseTransferService {
         throw new Error(`Leaf data not found for leaf ${leaf.leaf.id}`);
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const nodeOutPoint = {
+      const cpfpNodeOutPoint = {
         txid: hexToBytes8(getTxId(nodeTx)),
         index: 0
       };
+      let directNodeTx;
+      let directNodeOutPoint;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+        directNodeOutPoint = {
+          txid: hexToBytes8(getTxId(directNodeTx)),
+          index: 0
+        };
+      }
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-      const nextSequence = isForClaim ? getTransactionSequence(currRefundTx.getInput(0).sequence) : getNextTransactionSequence(currRefundTx.getInput(0).sequence).nextSequence;
+      const sequence = currRefundTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: currRefundTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const { nextSequence, nextDirectSequence } = isForClaim ? getTransactionSequence(sequence) : getNextTransactionSequence(sequence);
       const amountSats = currRefundTx.getOutput(0).amount;
       if (amountSats === void 0) {
         throw new Error("Amount not found in signRefunds");
       }
-      const refundTx = createRefundTx(
-        nextSequence,
-        nodeOutPoint,
+      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+        sequence: nextSequence,
+        directSequence: nextDirectSequence,
+        input: cpfpNodeOutPoint,
+        directInput: directNodeOutPoint,
         amountSats,
-        refundSigningData.receivingPubkey,
-        this.config.getNetwork()
+        receivingPubkey: refundSigningData.receivingPubkey,
+        network: this.config.getNetwork()
+      });
+      refundSigningData.refundTx = cpfpRefundTx;
+      refundSigningData.directRefundTx = directRefundTx;
+      refundSigningData.directFromCpfpRefundTx = directFromCpfpRefundTx;
+      const cpfpRefundNonceCommitmentProto = refundSigningData.signingNonceCommitment;
+      const directRefundNonceCommitmentProto = refundSigningData.directSigningNonceCommitment;
+      const directFromCpfpRefundNonceCommitmentProto = refundSigningData.directFromCpfpRefundSigningNonceCommitment;
+      const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(
+        refundSigningData.keyDerivation
       );
-      refundSigningData.refundTx = refundTx;
-      const refundNonceCommitmentProto = refundSigningData.signingNonceCommitment;
       signingJobs.push({
         leafId: leaf.leaf.id,
         refundTxSigningJob: {
-          signingPublicKey: await this.config.signer.getPublicKeyFromDerivation(
-            refundSigningData.keyDerivation
-          ),
-          rawTx: refundTx.toBytes(),
-          signingNonceCommitment: refundNonceCommitmentProto.commitment
+          signingPublicKey,
+          rawTx: cpfpRefundTx.toBytes(),
+          signingNonceCommitment: cpfpRefundNonceCommitmentProto.commitment
         },
-        // TODO: Add direct refund signature
-        directRefundTxSigningJob: void 0,
-        // TODO: Add direct refund signature
-        directFromCpfpRefundTxSigningJob: void 0
+        directRefundTxSigningJob: directRefundTx ? {
+          signingPublicKey,
+          rawTx: directRefundTx.toBytes(),
+          signingNonceCommitment: directRefundNonceCommitmentProto.commitment
+        } : void 0,
+        directFromCpfpRefundTxSigningJob: directFromCpfpRefundTx ? {
+          signingPublicKey,
+          rawTx: directFromCpfpRefundTx.toBytes(),
+          signingNonceCommitment: directFromCpfpRefundNonceCommitmentProto.commitment
+        } : void 0
       });
     }
     return signingJobs;
@@ -8261,13 +9086,17 @@ var TransferService = class extends BaseTransferService {
     const leafDataMap = /* @__PURE__ */ new Map();
     for (const leafKey of leafKeys) {
       const tx = getTxFromRawTxBytes(leafKey.leaf.nodeTx);
+      const directTx = leafKey.leaf.directTx.length > 0 ? getTxFromRawTxBytes(leafKey.leaf.directTx) : void 0;
       leafDataMap.set(leafKey.leaf.id, {
         keyDerivation: leafKey.newKeyDerivation,
         receivingPubkey: await this.config.signer.getPublicKeyFromDerivation(
           leafKey.newKeyDerivation
         ),
         signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        directSigningNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        directFromCpfpRefundSigningNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
         tx,
+        directTx,
         vout: leafKey.leaf.vout
       });
     }
@@ -8289,7 +9118,7 @@ var TransferService = class extends BaseTransferService {
       }
     }
     try {
-      resp = await sparkClient.claim_transfer_sign_refunds({
+      resp = await sparkClient.claim_transfer_sign_refunds_v2({
         transferId: transfer.id,
         ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
         signingJobs
@@ -8304,7 +9133,7 @@ var TransferService = class extends BaseTransferService {
       this.config.getCoordinatorAddress()
     );
     try {
-      return await sparkClient.finalize_node_signatures({
+      return await sparkClient.finalize_node_signatures_v2({
         intent: 1 /* TRANSFER */,
         nodeSignatures
       });
@@ -8343,109 +9172,134 @@ var TransferService = class extends BaseTransferService {
       throw new Error(`Error querying pending transfers by sender: ${error}`);
     }
   }
-  async refreshTimelockNodes(nodes, parentNode) {
-    if (nodes.length === 0) {
-      throw Error("no nodes to refresh");
-    }
+  async refreshTimelockNodesInternal(node, parentNode, useTestUnilateralSequence) {
     const signingJobs = [];
-    const newNodeTxs = [];
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      if (!node) {
-        throw Error("could not get node");
-      }
-      const nodeTx = getTxFromRawTxBytes(node?.nodeTx);
-      const input = nodeTx.getInput(0);
-      if (!input) {
-        throw Error("Could not fetch tx input");
-      }
-      const newTx = new Transaction5({ 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;
-        newTx.addInput({
-          ...input,
-          sequence: getNextTransactionSequence(currSequence).nextSequence
-        });
-      } else {
-        newTx.addInput({
-          ...input,
-          sequence: initialSequence(),
-          txid: newNodeTxs[i - 1]?.id
-        });
-      }
+    const parentNodeTx = getTxFromRawTxBytes(parentNode.nodeTx);
+    const parentNodeOutput = parentNodeTx.getOutput(0);
+    if (!parentNodeOutput) {
+      throw Error("Could not get parent node output");
+    }
+    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+    const nodeInput = nodeTx.getInput(0);
+    const nodeOutput = nodeTx.getOutput(0);
+    if (!nodeOutput) {
+      throw Error("Could not get node output");
+    }
+    let directNodeTx;
+    let directNodeInput;
+    if (node.directTx.length > 0) {
+      directNodeTx = getTxFromRawTxBytes(node.directTx);
+      directNodeInput = directNodeTx.getInput(0);
+    }
+    const currSequence = nodeInput.sequence;
+    if (!currSequence) {
+      throw new ValidationError("Invalid node transaction", {
+        field: "sequence",
+        value: nodeInput,
+        expected: "Non-null sequence"
+      });
+    }
+    let { nextSequence, nextDirectSequence } = getNextTransactionSequence(
+      currSequence,
+      true
+    );
+    const output = {
+      script: parentNodeOutput.script,
+      amount: parentNodeOutput.amount
+    };
+    const newNodeInput = {
+      txid: nodeInput.txid,
+      index: nodeInput.index,
+      sequence: useTestUnilateralSequence ? TEST_UNILATERAL_SEQUENCE : nextSequence
+    };
+    const newDirectInput = directNodeTx && directNodeInput ? {
+      txid: directNodeInput.txid,
+      index: directNodeInput.index,
+      sequence: useTestUnilateralSequence ? TEST_UNILATERAL_DIRECT_SEQUENCE : nextDirectSequence
+    } : void 0;
+    const { cpfpNodeTx, directNodeTx: newDirectNodeTx } = createNodeTxs(
+      output,
+      newNodeInput,
+      newDirectInput
+    );
+    const newCpfpNodeOutput = cpfpNodeTx.getOutput(0);
+    if (!newCpfpNodeOutput) {
+      throw Error("Could not get new cpfp node output");
+    }
+    const newDirectNodeOutput = newDirectNodeTx?.getOutput(0);
+    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation({
+      type: "leaf" /* LEAF */,
+      path: node.id
+    });
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: cpfpNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "node",
+      parentTxOut: parentNodeOutput
+    });
+    if (newDirectNodeTx) {
       signingJobs.push({
-        signingPublicKey: await this.config.signer.getPublicKeyFromDerivation({
-          type: "leaf" /* LEAF */,
-          path: node.id
-        }),
-        rawTx: newTx.toBytes(),
-        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+        signingPublicKey,
+        rawTx: newDirectNodeTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directNode",
+        parentTxOut: parentNodeOutput
       });
-      newNodeTxs[i] = newTx;
     }
-    const leaf = nodes[nodes.length - 1];
-    if (!leaf?.refundTx) {
-      throw Error("leaf does not have refund tx");
+    const newCpfpRefundOutPoint = {
+      txid: hexToBytes8(getTxId(cpfpNodeTx)),
+      index: 0
+    };
+    let newDirectRefundOutPoint;
+    if (newDirectNodeTx) {
+      newDirectRefundOutPoint = {
+        txid: hexToBytes8(getTxId(newDirectNodeTx)),
+        index: 0
+      };
     }
-    const refundTx = getTxFromRawTxBytes(leaf?.refundTx);
-    const newRefundTx = new Transaction5({
-      version: 3,
-      allowUnknownOutputs: true
+    const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+      sequence: INITIAL_SEQUENCE,
+      directSequence: INITIAL_DIRECT_SEQUENCE,
+      input: newCpfpRefundOutPoint,
+      directInput: newDirectRefundOutPoint,
+      amountSats: nodeOutput.amount,
+      receivingPubkey: await this.config.signer.getPublicKeyFromDerivation({
+        type: "leaf" /* LEAF */,
+        path: node.id
+      }),
+      network: this.config.getNetwork()
     });
-    const originalRefundOutput = refundTx.getOutput(0);
-    if (!originalRefundOutput) {
-      throw Error("Could not get original refund output");
-    }
-    newRefundTx.addOutput({
-      script: originalRefundOutput.script,
-      amount: originalRefundOutput.amount
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: cpfpRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "cpfp",
+      parentTxOut: newCpfpNodeOutput
     });
-    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");
+    if (directRefundTx && newDirectNodeOutput) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: directRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "direct",
+        parentTxOut: newDirectNodeOutput
+      });
     }
-    if (!newNodeTxs[newNodeTxs.length - 1]) {
-      throw Error("Could not get last node tx");
+    if (directFromCpfpRefundTx && newCpfpNodeOutput) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: directFromCpfpRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directFromCpfp",
+        parentTxOut: newCpfpNodeOutput
+      });
     }
-    newRefundTx.addInput({
-      ...refundTxInput,
-      sequence: initialSequence(),
-      txid: getTxId(newNodeTxs[newNodeTxs.length - 1])
-    });
-    const refundSigningJob = {
-      signingPublicKey: await this.config.signer.getPublicKeyFromDerivation({
-        type: "leaf" /* LEAF */,
-        path: leaf.id
-      }),
-      rawTx: newRefundTx.toBytes(),
-      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
-    };
-    signingJobs.push(refundSigningJob);
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const response = await sparkClient.refresh_timelock({
-      leafId: leaf.id,
+    const response = await sparkClient.refresh_timelock_v2({
+      leafId: node.id,
       ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
       signingJobs: signingJobs.map(getSigningJobProto)
     });
@@ -8455,45 +9309,27 @@ var TransferService = class extends BaseTransferService {
       );
     }
     let nodeSignatures = [];
-    let leafSignature;
-    let refundSignature;
-    let leafNodeId;
-    for (let i = 0; i < response.signingResults.length; i++) {
-      const signingResult = response.signingResults[i];
+    let leafCpfpSignature;
+    let leafDirectSignature;
+    let cpfpRefundSignature;
+    let directRefundSignature;
+    let directFromCpfpRefundSignature;
+    for (const [i, signingResult] of response.signingResults.entries()) {
       const signingJob = signingJobs[i];
       if (!signingJob || !signingResult) {
         throw Error("Signing job does not exist");
       }
-      if (!signingJob.signingNonceCommitment) {
-        throw Error("nonce commitment does not exist");
-      }
       const rawTx = getTxFromRawTxBytes(signingJob.rawTx);
-      let parentTx;
-      let nodeId;
-      let vout;
-      if (i === nodes.length) {
-        nodeId = nodes[i - 1]?.id;
-        parentTx = newNodeTxs[i - 1];
-        vout = 0;
-      } else if (i === 0) {
-        nodeId = nodes[i]?.id;
-        parentTx = getTxFromRawTxBytes(parentNode.nodeTx);
-        vout = nodes[i]?.vout;
-      } else {
-        nodeId = nodes[i]?.id;
-        parentTx = newNodeTxs[i - 1];
-        vout = nodes[i]?.vout;
+      const txOut = signingJob.parentTxOut;
+      if (!txOut) {
+        throw Error("Could not get tx out");
       }
-      if (!parentTx || !nodeId || vout === void 0) {
-        throw Error("Could not parse signing results");
-      }
-      const txOut = parentTx.getOutput(vout);
       const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
       const userSignature = await this.config.signer.signFrost({
         message: rawTxSighash,
         keyDerivation: {
           type: "leaf" /* LEAF */,
-          path: nodeId
+          path: node.id
         },
         publicKey: signingJob.signingPublicKey,
         verifyingKey: signingResult.verifyingKey,
@@ -8512,41 +9348,35 @@ var TransferService = class extends BaseTransferService {
         selfSignature: userSignature,
         adaptorPubKey: new Uint8Array()
       });
-      if (i !== nodes.length && i !== nodes.length - 1) {
-        nodeSignatures.push({
-          nodeId,
-          nodeTxSignature: signature,
-          refundTxSignature: new Uint8Array(),
-          // TODO: Add direct refund signature
-          directNodeTxSignature: new Uint8Array(),
-          directRefundTxSignature: new Uint8Array(),
-          directFromCpfpRefundTxSignature: new Uint8Array()
-        });
-      } else if (i === nodes.length) {
-        refundSignature = signature;
-      } else if (i === nodes.length - 1) {
-        leafNodeId = nodeId;
-        leafSignature = signature;
+      if (signingJob.type === "node") {
+        leafCpfpSignature = signature;
+      } else if (signingJob.type === "directNode") {
+        leafDirectSignature = signature;
+      } else if (signingJob.type === "cpfp") {
+        cpfpRefundSignature = signature;
+      } else if (signingJob.type === "direct") {
+        directRefundSignature = signature;
+      } else if (signingJob.type === "directFromCpfp") {
+        directFromCpfpRefundSignature = signature;
       }
     }
-    if (!leafSignature || !refundSignature || !leafNodeId) {
-      throw Error("leaf or refund signature does not exist");
-    }
     nodeSignatures.push({
-      nodeId: leafNodeId,
-      nodeTxSignature: leafSignature,
-      refundTxSignature: refundSignature,
-      // TODO: Add direct refund signature
-      directNodeTxSignature: new Uint8Array(),
-      directRefundTxSignature: new Uint8Array(),
-      directFromCpfpRefundTxSignature: new Uint8Array()
-    });
-    const result = await sparkClient.finalize_node_signatures({
+      nodeId: node.id,
+      nodeTxSignature: leafCpfpSignature || new Uint8Array(),
+      directNodeTxSignature: leafDirectSignature || new Uint8Array(),
+      refundTxSignature: cpfpRefundSignature || new Uint8Array(),
+      directRefundTxSignature: directRefundSignature || new Uint8Array(),
+      directFromCpfpRefundTxSignature: directFromCpfpRefundSignature || new Uint8Array()
+    });
+    const result = await sparkClient.finalize_node_signatures_v2({
       intent: 3 /* REFRESH */,
       nodeSignatures
     });
     return result;
   }
+  async refreshTimelockNodes(node, parentNode) {
+    return await this.refreshTimelockNodesInternal(node, parentNode);
+  }
   async extendTimelock(node) {
     const nodeTx = getTxFromRawTxBytes(node.nodeTx);
     const refundTx = getTxFromRawTxBytes(node.refundTx);
@@ -8555,7 +9385,10 @@ var TransferService = class extends BaseTransferService {
       txid: hexToBytes8(getTxId(nodeTx)),
       index: 0
     };
-    const { nextSequence: newNodeSequence } = getNextTransactionSequence(refundSequence);
+    const {
+      nextSequence: newNodeSequence,
+      nextDirectSequence: newDirectNodeSequence
+    } = getNextTransactionSequence(refundSequence);
     const newNodeTx = new Transaction5({
       version: 3,
       allowUnknownOutputs: true
@@ -8568,81 +9401,122 @@ var TransferService = class extends BaseTransferService {
     newNodeTx.addOutput({
       script: originalOutput.script,
       amount: originalOutput.amount
-      // feeReducedAmount,
     });
     newNodeTx.addOutput(getEphemeralAnchorOutput());
-    const newRefundOutPoint = {
+    let newDirectNodeTx;
+    if (node.directTx.length > 0) {
+      newDirectNodeTx = new Transaction5({
+        version: 3,
+        allowUnknownOutputs: true
+      });
+      newDirectNodeTx.addInput({
+        ...newNodeOutPoint,
+        sequence: newDirectNodeSequence
+      });
+      newDirectNodeTx.addOutput({
+        script: originalOutput.script,
+        amount: maybeApplyFee(originalOutput.amount)
+      });
+    }
+    const newCpfpRefundOutPoint = {
       txid: hexToBytes8(getTxId(newNodeTx)),
       index: 0
     };
+    let newDirectRefundOutPoint;
+    if (newDirectNodeTx) {
+      newDirectRefundOutPoint = {
+        txid: hexToBytes8(getTxId(newDirectNodeTx)),
+        index: 0
+      };
+    }
     const amountSats = refundTx.getOutput(0).amount;
     if (amountSats === void 0) {
       throw new Error("Amount not found in extendTimelock");
     }
-    const signingPubKey = await this.config.signer.getPublicKeyFromDerivation({
+    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation({
       type: "leaf" /* LEAF */,
       path: node.id
     });
-    const newRefundTx = createRefundTx(
-      initialSequence(),
-      newRefundOutPoint,
+    const {
+      cpfpRefundTx: newCpfpRefundTx,
+      directRefundTx: newDirectRefundTx,
+      directFromCpfpRefundTx: newDirectFromCpfpRefundTx
+    } = createRefundTxs({
+      sequence: INITIAL_SEQUENCE,
+      directSequence: INITIAL_DIRECT_SEQUENCE,
+      input: newCpfpRefundOutPoint,
+      directInput: newDirectRefundOutPoint,
       amountSats,
-      // feeReducedRefundAmount,
-      signingPubKey,
-      this.config.getNetwork()
-    );
+      receivingPubkey: signingPublicKey,
+      network: this.config.getNetwork()
+    });
+    if (!newCpfpRefundTx) {
+      throw new ValidationError(
+        "Failed to create refund transactions in extendTimelock"
+      );
+    }
     const nodeSighash = getSigHashFromTx(newNodeTx, 0, nodeTx.getOutput(0));
-    const refundSighash = getSigHashFromTx(
-      newRefundTx,
+    const directNodeSighash = newDirectNodeTx ? getSigHashFromTx(newDirectNodeTx, 0, nodeTx.getOutput(0)) : void 0;
+    const cpfpRefundSighash = getSigHashFromTx(
+      newCpfpRefundTx,
       0,
       newNodeTx.getOutput(0)
     );
+    const directRefundSighash = newDirectNodeTx && newDirectRefundTx ? getSigHashFromTx(newDirectRefundTx, 0, newDirectNodeTx.getOutput(0)) : void 0;
+    const directFromCpfpRefundSighash = newDirectFromCpfpRefundTx ? getSigHashFromTx(newDirectFromCpfpRefundTx, 0, newNodeTx.getOutput(0)) : void 0;
     const newNodeSigningJob = {
-      signingPublicKey: signingPubKey,
+      signingPublicKey,
       rawTx: newNodeTx.toBytes(),
       signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
     };
-    const newRefundSigningJob = {
-      signingPublicKey: signingPubKey,
-      rawTx: newRefundTx.toBytes(),
+    const newDirectNodeSigningJob = newDirectNodeTx ? {
+      signingPublicKey,
+      rawTx: newDirectNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    } : void 0;
+    const newCpfpRefundSigningJob = {
+      signingPublicKey,
+      rawTx: newCpfpRefundTx.toBytes(),
       signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
     };
+    const newDirectRefundSigningJob = newDirectRefundTx ? {
+      signingPublicKey,
+      rawTx: newDirectRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    } : void 0;
+    const newDirectFromCpfpRefundSigningJob = newDirectFromCpfpRefundTx ? {
+      signingPublicKey,
+      rawTx: newDirectFromCpfpRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    } : void 0;
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const response = await sparkClient.extend_leaf({
+    const response = await sparkClient.extend_leaf_v2({
       leafId: node.id,
       ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
       nodeTxSigningJob: getSigningJobProto(newNodeSigningJob),
-      refundTxSigningJob: getSigningJobProto(newRefundSigningJob)
+      directNodeTxSigningJob: newDirectNodeSigningJob ? getSigningJobProto(newDirectNodeSigningJob) : void 0,
+      refundTxSigningJob: getSigningJobProto(newCpfpRefundSigningJob),
+      directRefundTxSigningJob: newDirectRefundSigningJob ? getSigningJobProto(newDirectRefundSigningJob) : void 0,
+      directFromCpfpRefundTxSigningJob: newDirectFromCpfpRefundSigningJob ? getSigningJobProto(newDirectFromCpfpRefundSigningJob) : void 0
     });
     if (!response.nodeTxSigningResult || !response.refundTxSigningResult) {
       throw new Error("Signing result does not exist");
     }
+    const keyDerivation = {
+      type: "leaf" /* LEAF */,
+      path: node.id
+    };
     const nodeUserSig = await this.config.signer.signFrost({
       message: nodeSighash,
-      keyDerivation: {
-        type: "leaf" /* LEAF */,
-        path: node.id
-      },
-      publicKey: signingPubKey,
+      keyDerivation,
+      publicKey: signingPublicKey,
       verifyingKey: response.nodeTxSigningResult.verifyingKey,
       selfCommitment: newNodeSigningJob.signingNonceCommitment,
       statechainCommitments: response.nodeTxSigningResult.signingResult?.signingNonceCommitments,
       adaptorPubKey: new Uint8Array()
     });
-    const refundUserSig = await this.config.signer.signFrost({
-      message: refundSighash,
-      keyDerivation: {
-        type: "leaf" /* LEAF */,
-        path: node.id
-      },
-      publicKey: signingPubKey,
-      verifyingKey: response.refundTxSigningResult.verifyingKey,
-      selfCommitment: newRefundSigningJob.signingNonceCommitment,
-      statechainCommitments: response.refundTxSigningResult.signingResult?.signingNonceCommitments,
-      adaptorPubKey: new Uint8Array()
-    });
     const nodeSig = await this.config.signer.aggregateFrost({
       message: nodeSighash,
       statechainSignatures: response.nodeTxSigningResult.signingResult?.signatureShares,
@@ -8650,122 +9524,253 @@ var TransferService = class extends BaseTransferService {
       verifyingKey: response.nodeTxSigningResult.verifyingKey,
       statechainCommitments: response.nodeTxSigningResult.signingResult?.signingNonceCommitments,
       selfCommitment: newNodeSigningJob.signingNonceCommitment,
-      publicKey: signingPubKey,
+      publicKey: signingPublicKey,
       selfSignature: nodeUserSig,
       adaptorPubKey: new Uint8Array()
     });
-    const refundSig = await this.config.signer.aggregateFrost({
-      message: refundSighash,
+    let directNodeSig;
+    if (directNodeSighash && newDirectNodeSigningJob && response.directNodeTxSigningResult) {
+      const directNodeUserSig = await this.config.signer.signFrost({
+        message: directNodeSighash,
+        keyDerivation,
+        publicKey: signingPublicKey,
+        verifyingKey: response.directNodeTxSigningResult.verifyingKey,
+        selfCommitment: newDirectNodeSigningJob.signingNonceCommitment,
+        statechainCommitments: response.directNodeTxSigningResult.signingResult?.signingNonceCommitments,
+        adaptorPubKey: new Uint8Array()
+      });
+      directNodeSig = await this.config.signer.aggregateFrost({
+        message: directNodeSighash,
+        statechainSignatures: response.directNodeTxSigningResult.signingResult?.signatureShares,
+        statechainPublicKeys: response.directNodeTxSigningResult.signingResult?.publicKeys,
+        verifyingKey: response.directNodeTxSigningResult.verifyingKey,
+        statechainCommitments: response.directNodeTxSigningResult.signingResult?.signingNonceCommitments,
+        selfCommitment: newDirectNodeSigningJob.signingNonceCommitment,
+        publicKey: signingPublicKey,
+        selfSignature: directNodeUserSig,
+        adaptorPubKey: new Uint8Array()
+      });
+    }
+    const cpfpRefundUserSig = await this.config.signer.signFrost({
+      message: cpfpRefundSighash,
+      keyDerivation,
+      publicKey: signingPublicKey,
+      verifyingKey: response.refundTxSigningResult.verifyingKey,
+      selfCommitment: newCpfpRefundSigningJob.signingNonceCommitment,
+      statechainCommitments: response.refundTxSigningResult.signingResult?.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const cpfpRefundSig = await this.config.signer.aggregateFrost({
+      message: cpfpRefundSighash,
       statechainSignatures: response.refundTxSigningResult.signingResult?.signatureShares,
       statechainPublicKeys: response.refundTxSigningResult.signingResult?.publicKeys,
       verifyingKey: response.refundTxSigningResult.verifyingKey,
       statechainCommitments: response.refundTxSigningResult.signingResult?.signingNonceCommitments,
-      selfCommitment: newRefundSigningJob.signingNonceCommitment,
-      publicKey: signingPubKey,
-      selfSignature: refundUserSig,
+      selfCommitment: newCpfpRefundSigningJob.signingNonceCommitment,
+      publicKey: signingPublicKey,
+      selfSignature: cpfpRefundUserSig,
       adaptorPubKey: new Uint8Array()
     });
-    return await sparkClient.finalize_node_signatures({
+    let directRefundSig;
+    if (directRefundSighash && newDirectRefundSigningJob && response.directRefundTxSigningResult) {
+      const directRefundUserSig = await this.config.signer.signFrost({
+        message: directRefundSighash,
+        keyDerivation,
+        publicKey: signingPublicKey,
+        verifyingKey: response.directRefundTxSigningResult.verifyingKey,
+        selfCommitment: newDirectRefundSigningJob.signingNonceCommitment,
+        statechainCommitments: response.directRefundTxSigningResult.signingResult?.signingNonceCommitments,
+        adaptorPubKey: new Uint8Array()
+      });
+      directRefundSig = await this.config.signer.aggregateFrost({
+        message: directRefundSighash,
+        statechainSignatures: response.directRefundTxSigningResult.signingResult?.signatureShares,
+        statechainPublicKeys: response.directRefundTxSigningResult.signingResult?.publicKeys,
+        verifyingKey: response.directRefundTxSigningResult.verifyingKey,
+        statechainCommitments: response.directRefundTxSigningResult.signingResult?.signingNonceCommitments,
+        selfCommitment: newDirectRefundSigningJob.signingNonceCommitment,
+        publicKey: signingPublicKey,
+        selfSignature: directRefundUserSig,
+        adaptorPubKey: new Uint8Array()
+      });
+    }
+    let directFromCpfpRefundSig;
+    if (directFromCpfpRefundSighash && newDirectFromCpfpRefundSigningJob && response.directFromCpfpRefundTxSigningResult) {
+      const directFromCpfpRefundUserSig = await this.config.signer.signFrost({
+        message: directFromCpfpRefundSighash,
+        keyDerivation,
+        publicKey: signingPublicKey,
+        verifyingKey: response.directFromCpfpRefundTxSigningResult.verifyingKey,
+        selfCommitment: newDirectFromCpfpRefundSigningJob.signingNonceCommitment,
+        statechainCommitments: response.directFromCpfpRefundTxSigningResult.signingResult?.signingNonceCommitments,
+        adaptorPubKey: new Uint8Array()
+      });
+      directFromCpfpRefundSig = await this.config.signer.aggregateFrost({
+        message: directFromCpfpRefundSighash,
+        statechainSignatures: response.directFromCpfpRefundTxSigningResult.signingResult?.signatureShares,
+        statechainPublicKeys: response.directFromCpfpRefundTxSigningResult.signingResult?.publicKeys,
+        verifyingKey: response.directFromCpfpRefundTxSigningResult.verifyingKey,
+        statechainCommitments: response.directFromCpfpRefundTxSigningResult.signingResult?.signingNonceCommitments,
+        selfCommitment: newDirectFromCpfpRefundSigningJob.signingNonceCommitment,
+        publicKey: signingPublicKey,
+        selfSignature: directFromCpfpRefundUserSig,
+        adaptorPubKey: new Uint8Array()
+      });
+    }
+    return await sparkClient.finalize_node_signatures_v2({
       intent: 4 /* EXTEND */,
       nodeSignatures: [
         {
           nodeId: response.leafId,
           nodeTxSignature: nodeSig,
-          refundTxSignature: refundSig
+          directNodeTxSignature: directNodeSig,
+          refundTxSignature: cpfpRefundSig,
+          directRefundTxSignature: directRefundSig,
+          directFromCpfpRefundTxSignature: directFromCpfpRefundSig
         }
       ]
     });
   }
-  async refreshTimelockRefundTx(node) {
+  async testonly_expireTimeLockNodeTx(node, parentNode) {
+    return await this.refreshTimelockNodesInternal(node, parentNode, true);
+  }
+  async testonly_expireTimeLockRefundtx(node) {
     const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-    const refundTx = getTxFromRawTxBytes(node.refundTx);
-    const currSequence = refundTx.getInput(0).sequence || 0;
-    const { nextSequence } = getNextTransactionSequence(currSequence);
-    const signingPubKey = await this.config.signer.getPublicKeyFromDerivation({
+    const directNodeTx = node.directTx.length > 0 ? getTxFromRawTxBytes(node.directTx) : void 0;
+    const cpfpRefundTx = getTxFromRawTxBytes(node.refundTx);
+    const currSequence = cpfpRefundTx.getInput(0).sequence || 0;
+    const currTimelock = getCurrentTimelock(currSequence);
+    if (currTimelock <= 100) {
+      throw new ValidationError("Cannot expire timelock below 100", {
+        field: "currTimelock",
+        value: currTimelock,
+        expected: "Timelock greater than 100"
+      });
+    }
+    const nextSequence = TEST_UNILATERAL_SEQUENCE;
+    const nextDirectSequence = TEST_UNILATERAL_SEQUENCE + DIRECT_TIMELOCK_OFFSET;
+    const nodeOutput = nodeTx.getOutput(0);
+    if (!nodeOutput) {
+      throw Error("Could not get node output");
+    }
+    const keyDerivation = {
       type: "leaf" /* LEAF */,
       path: node.id
-    });
-    const newRefundTx = new Transaction5({
-      version: 3,
-      allowUnknownOutputs: true
-    });
-    const originalRefundOutput = refundTx.getOutput(0);
-    if (!originalRefundOutput) {
-      throw Error("Could not get original refund output");
+    };
+    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
+    const cpfpRefundOutPoint = {
+      txid: hexToBytes8(getTxId(nodeTx)),
+      index: 0
+    };
+    let directRefundOutPoint;
+    if (directNodeTx) {
+      directRefundOutPoint = {
+        txid: hexToBytes8(getTxId(directNodeTx)),
+        index: 0
+      };
     }
-    newRefundTx.addOutput({
-      script: originalRefundOutput.script,
-      amount: originalRefundOutput.amount
+    const {
+      cpfpRefundTx: newCpfpRefundTx,
+      directRefundTx: newDirectRefundTx,
+      directFromCpfpRefundTx: newDirectFromCpfpRefundTx
+    } = createRefundTxs({
+      sequence: nextSequence,
+      directSequence: nextDirectSequence,
+      input: cpfpRefundOutPoint,
+      directInput: directRefundOutPoint,
+      amountSats: nodeOutput.amount,
+      receivingPubkey: signingPublicKey,
+      network: this.config.getNetwork()
     });
-    for (let j = 1; j < refundTx.outputsLength; j++) {
-      const additionalOutput = refundTx.getOutput(j);
-      if (additionalOutput) {
-        newRefundTx.addOutput(additionalOutput);
-      }
+    const signingJobs = [];
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: newCpfpRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "cpfp",
+      parentTxOut: nodeOutput
+    });
+    const directNodeTxOut = directNodeTx?.getOutput(0);
+    if (newDirectRefundTx && directNodeTxOut) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: newDirectRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "direct",
+        parentTxOut: directNodeTxOut
+      });
     }
-    const refundTxInput = refundTx.getInput(0);
-    if (!refundTxInput) {
-      throw Error("refund tx doesn't have input");
+    if (newDirectFromCpfpRefundTx) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: newDirectFromCpfpRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directFromCpfp",
+        parentTxOut: nodeOutput
+      });
     }
-    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({
+    const response = await sparkClient.refresh_timelock_v2({
       leafId: node.id,
       ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-      signingJobs: [getSigningJobProto(refundSigningJob)]
+      signingJobs: signingJobs.map(getSigningJobProto)
     });
-    if (response.signingResults.length !== 1) {
+    if (response.signingResults.length !== signingJobs.length) {
       throw Error(
-        `Expected 1 signing result, got ${response.signingResults.length}`
+        `Expected ${signingJobs.length} signing results, got ${response.signingResults.length}`
       );
     }
-    const signingResult = response.signingResults[0];
-    if (!signingResult || !refundSigningJob.signingNonceCommitment) {
-      throw Error("Signing result or nonce commitment does not exist");
+    let cpfpRefundSignature;
+    let directRefundSignature;
+    let directFromCpfpRefundSignature;
+    for (const [i, signingJob] of signingJobs.entries()) {
+      const signingResult = response.signingResults[i];
+      if (!signingResult) {
+        throw Error("Signing result does not exist");
+      }
+      const rawTx = getTxFromRawTxBytes(signingJob.rawTx);
+      const txOut = signingJob.parentTxOut;
+      const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
+      const userSignature = await this.config.signer.signFrost({
+        message: rawTxSighash,
+        keyDerivation,
+        publicKey: signingPublicKey,
+        verifyingKey: signingResult.verifyingKey,
+        selfCommitment: signingJob.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: signingJob.signingNonceCommitment,
+        publicKey: signingPublicKey,
+        selfSignature: userSignature,
+        adaptorPubKey: new Uint8Array()
+      });
+      if (signingJob.type === "cpfp") {
+        cpfpRefundSignature = signature;
+      } else if (signingJob.type === "direct") {
+        directRefundSignature = signature;
+      } else if (signingJob.type === "directFromCpfp") {
+        directFromCpfpRefundSignature = signature;
+      }
     }
-    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,
-      keyDerivation: {
-        type: "leaf" /* LEAF */,
-        path: node.id
-      },
-      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({
+    const result = await sparkClient.finalize_node_signatures_v2({
       intent: 3 /* REFRESH */,
       nodeSignatures: [
         {
           nodeId: node.id,
           nodeTxSignature: new Uint8Array(),
-          refundTxSignature: signature
+          directNodeTxSignature: new Uint8Array(),
+          refundTxSignature: cpfpRefundSignature,
+          directRefundTxSignature: directRefundSignature,
+          directFromCpfpRefundTxSignature: directFromCpfpRefundSignature
         }
       ]
     });
@@ -8784,7 +9789,12 @@ var CoopExitService = class extends BaseTransferService {
     connectorOutputs,
     receiverPubKey
   }) {
-    const { transfer, signaturesMap } = await this.signCoopExitRefunds(
+    const {
+      transfer,
+      signaturesMap,
+      directSignaturesMap,
+      directFromCpfpSignaturesMap
+    } = await this.signCoopExitRefunds(
       leaves,
       exitTxId,
       connectorOutputs,
@@ -8793,34 +9803,81 @@ var CoopExitService = class extends BaseTransferService {
     const transferTweak = await this.deliverTransferPackage(
       transfer,
       leaves,
-      signaturesMap
+      signaturesMap,
+      directSignaturesMap,
+      directFromCpfpSignaturesMap
     );
-    return { transfer: transferTweak, signaturesMap };
+    return {
+      transfer: transferTweak,
+      signaturesMap,
+      directSignaturesMap,
+      directFromCpfpSignaturesMap
+    };
   }
-  createConnectorRefundTransaction(sequence, nodeOutPoint, connectorOutput, amountSats, receiverPubKey) {
-    const refundTx = new Transaction6();
-    if (!nodeOutPoint.txid || nodeOutPoint.index === void 0) {
-      throw new ValidationError("Invalid node outpoint", {
-        field: "nodeOutPoint",
-        value: { txid: nodeOutPoint.txid, index: nodeOutPoint.index },
+  createConnectorRefundTransactions(sequence, directSequence, cpfpNodeOutPoint, directNodeOutPoint, connectorOutput, amountSats, receiverPubKey) {
+    const cpfpRefundTx = new Transaction6();
+    if (!cpfpNodeOutPoint.txid || cpfpNodeOutPoint.index === void 0) {
+      throw new ValidationError("Invalid CPFP node outpoint", {
+        field: "cpfpNodeOutPoint",
+        value: { txid: cpfpNodeOutPoint.txid, index: cpfpNodeOutPoint.index },
         expected: "Both txid and index must be defined"
       });
     }
-    refundTx.addInput({
-      txid: nodeOutPoint.txid,
-      index: nodeOutPoint.index,
+    cpfpRefundTx.addInput({
+      txid: cpfpNodeOutPoint.txid,
+      index: cpfpNodeOutPoint.index,
       sequence
     });
-    refundTx.addInput(connectorOutput);
+    cpfpRefundTx.addInput(connectorOutput);
     const receiverScript = getP2TRScriptFromPublicKey(
       receiverPubKey,
       this.config.getNetwork()
     );
-    refundTx.addOutput({
+    cpfpRefundTx.addOutput({
       script: receiverScript,
       amount: amountSats
     });
-    return refundTx;
+    let directRefundTx;
+    let directFromCpfpRefundTx;
+    if (directNodeOutPoint) {
+      if (!directNodeOutPoint.txid || directNodeOutPoint.index === void 0) {
+        throw new ValidationError("Invalid direct node outpoint", {
+          field: "directNodeOutPoint",
+          value: {
+            txid: directNodeOutPoint.txid,
+            index: directNodeOutPoint.index
+          },
+          expected: "Both txid and index must be defined"
+        });
+      }
+      directRefundTx = new Transaction6();
+      directRefundTx.addInput({
+        txid: directNodeOutPoint.txid,
+        index: directNodeOutPoint.index,
+        sequence: directSequence
+      });
+      directRefundTx.addInput(connectorOutput);
+      directRefundTx.addOutput({
+        script: receiverScript,
+        amount: maybeApplyFee(amountSats)
+      });
+      directFromCpfpRefundTx = new Transaction6();
+      directFromCpfpRefundTx.addInput({
+        txid: cpfpNodeOutPoint.txid,
+        index: cpfpNodeOutPoint.index,
+        sequence: directSequence
+      });
+      directFromCpfpRefundTx.addInput(connectorOutput);
+      directFromCpfpRefundTx.addOutput({
+        script: receiverScript,
+        amount: maybeApplyFee(amountSats)
+      });
+    }
+    return {
+      cpfpRefundTx,
+      directRefundTx,
+      directFromCpfpRefundTx
+    };
   }
   async signCoopExitRefunds(leaves, exitTxId, connectorOutputs, receiverPubKey) {
     if (leaves.length !== connectorOutputs.length) {
@@ -8856,39 +9913,67 @@ var CoopExitService = class extends BaseTransferService {
         });
       }
       const currentRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-      const { nextSequence } = getNextTransactionSequence(
-        currentRefundTx.getInput(0).sequence
-      );
-      const refundTx = this.createConnectorRefundTransaction(
+      const sequence = currentRefundTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: currentRefundTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const { nextSequence, nextDirectSequence } = getNextTransactionSequence(sequence);
+      let currentDirectRefundTx;
+      if (leaf.leaf.directRefundTx.length > 0) {
+        currentDirectRefundTx = getTxFromRawTxBytes(leaf.leaf.directRefundTx);
+      }
+      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = this.createConnectorRefundTransactions(
         nextSequence,
+        nextDirectSequence,
         currentRefundTx.getInput(0),
+        currentDirectRefundTx?.getInput(0),
         connectorOutput,
         BigInt(leaf.leaf.value),
         receiverPubKey
       );
       const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const directSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const directFromCpfpSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+      const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(leaf.keyDerivation);
       const signingJob = {
         leafId: leaf.leaf.id,
         refundTxSigningJob: {
           signingPublicKey: await this.config.signer.getPublicKeyFromDerivation(
             leaf.keyDerivation
           ),
-          rawTx: refundTx.toBytes(),
+          rawTx: cpfpRefundTx.toBytes(),
           signingNonceCommitment: signingNonceCommitment.commitment
         },
-        // TODO: Add direct refund signature
-        directRefundTxSigningJob: void 0,
-        directFromCpfpRefundTxSigningJob: void 0
+        directRefundTxSigningJob: directRefundTx ? {
+          signingPublicKey,
+          rawTx: directRefundTx.toBytes(),
+          signingNonceCommitment: directSigningNonceCommitment.commitment
+        } : void 0,
+        directFromCpfpRefundTxSigningJob: directFromCpfpRefundTx ? {
+          signingPublicKey,
+          rawTx: directFromCpfpRefundTx.toBytes(),
+          signingNonceCommitment: directFromCpfpSigningNonceCommitment.commitment
+        } : void 0
       };
       signingJobs.push(signingJob);
       const tx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      const directTx = leaf.leaf.directTx.length > 0 ? getTxFromRawTxBytes(leaf.leaf.directTx) : void 0;
       leafDataMap.set(leaf.leaf.id, {
         keyDerivation: leaf.keyDerivation,
-        refundTx,
+        receivingPubkey: receiverPubKey,
         signingNonceCommitment,
+        directSigningNonceCommitment,
         tx,
-        vout: leaf.leaf.vout,
-        receivingPubkey: receiverPubKey
+        directTx,
+        refundTx: cpfpRefundTx,
+        directRefundTx,
+        directFromCpfpRefundTx,
+        directFromCpfpRefundSigningNonceCommitment: directFromCpfpSigningNonceCommitment,
+        vout: leaf.leaf.vout
       });
     }
     const sparkClient = await this.connectionManager.createSparkClient(
@@ -8896,7 +9981,7 @@ var CoopExitService = class extends BaseTransferService {
     );
     let response;
     try {
-      response = await sparkClient.cooperative_exit({
+      response = await sparkClient.cooperative_exit_v2({
         transfer: {
           transferId: uuidv73(),
           leavesToSend: signingJobs,
@@ -8930,10 +10015,25 @@ var CoopExitService = class extends BaseTransferService {
       response.signingResults
     );
     const signaturesMap = /* @__PURE__ */ new Map();
+    const directSignaturesMap = /* @__PURE__ */ new Map();
+    const directFromCpfpSignaturesMap = /* @__PURE__ */ new Map();
     for (const signature of signatures) {
       signaturesMap.set(signature.nodeId, signature.refundTxSignature);
+      directSignaturesMap.set(
+        signature.nodeId,
+        signature.directRefundTxSignature
+      );
+      directFromCpfpSignaturesMap.set(
+        signature.nodeId,
+        signature.directFromCpfpRefundTxSignature
+      );
     }
-    return { transfer: response.transfer, signaturesMap };
+    return {
+      transfer: response.transfer,
+      signaturesMap,
+      directSignaturesMap,
+      directFromCpfpSignaturesMap
+    };
   }
 };
 
@@ -9130,7 +10230,8 @@ var LightningService = class {
     let signingCommitments;
     try {
       signingCommitments = await sparkClient.get_signing_commitments({
-        nodeIds: leaves.map((leaf) => leaf.leaf.id)
+        nodeIds: leaves.map((leaf) => leaf.leaf.id),
+        count: 3
       });
     } catch (error) {
       throw new NetworkError(
@@ -9143,10 +10244,19 @@ var LightningService = class {
         error
       );
     }
-    const leafSigningJobs = await this.signingService.signRefunds(
+    const {
+      cpfpLeafSigningJobs,
+      directLeafSigningJobs,
+      directFromCpfpLeafSigningJobs
+    } = await this.signingService.signRefunds(
       leaves,
-      signingCommitments.signingCommitments,
-      receiverIdentityPubkey
+      receiverIdentityPubkey,
+      signingCommitments.signingCommitments.slice(0, leaves.length),
+      signingCommitments.signingCommitments.slice(
+        leaves.length,
+        2 * leaves.length
+      ),
+      signingCommitments.signingCommitments.slice(2 * leaves.length)
     );
     const transferId = uuidv74();
     let bolt11String = "";
@@ -9183,7 +10293,7 @@ var LightningService = class {
     const reason = isInboundPayment ? 1 /* REASON_RECEIVE */ : 0 /* REASON_SEND */;
     let response;
     try {
-      response = await sparkClient.initiate_preimage_swap({
+      response = await sparkClient.initiate_preimage_swap_v2({
         paymentHash,
         invoiceAmount: {
           invoiceAmountProof: {
@@ -9195,7 +10305,9 @@ var LightningService = class {
         transfer: {
           transferId,
           ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-          leavesToSend: leafSigningJobs,
+          leavesToSend: cpfpLeafSigningJobs,
+          directLeavesToSend: directLeafSigningJobs,
+          directFromCpfpLeavesToSend: directFromCpfpLeafSigningJobs,
           receiverIdentityPublicKey: receiverIdentityPubkey,
           expiryTime: new Date(Date.now() + 2 * 60 * 1e3)
         },
@@ -9278,14 +10390,7 @@ var LightningService = class {
 
 // src/services/tree-creation.ts
 import { hexToBytes as hexToBytes10 } from "@noble/curves/abstract/utils";
-import { Address as Address4, OutScript as OutScript4, Transaction as Transaction7 } from "@scure/btc-signer";
-var INITIAL_TIME_LOCK3 = 2e3;
-function maybeApplyFee2(amount) {
-  if (amount > BigInt(DEFAULT_FEE_SATS)) {
-    return amount - BigInt(DEFAULT_FEE_SATS);
-  }
-  return amount;
-}
+import { Address as Address3, OutScript as OutScript3 } from "@scure/btc-signer";
 var TreeCreationService = class {
   config;
   connectionManager;
@@ -9400,7 +10505,7 @@ var TreeCreationService = class {
     );
     let response;
     try {
-      response = await sparkClient.create_tree(request);
+      response = await sparkClient.create_tree_v2(request);
     } catch (error) {
       throw new Error(`Error creating tree: ${error}`);
     }
@@ -9417,7 +10522,7 @@ var TreeCreationService = class {
     );
     let finalizeResp;
     try {
-      finalizeResp = await sparkClient.finalize_node_signatures({
+      finalizeResp = await sparkClient.finalize_node_signatures_v2({
         nodeSignatures
       });
     } catch (error) {
@@ -9482,91 +10587,111 @@ var TreeCreationService = class {
   async buildChildCreationNode(node, parentTx, vout, network) {
     const internalCreationNode = {
       nodeTxSigningJob: void 0,
-      refundTxSigningJob: void 0,
-      children: [],
       directNodeTxSigningJob: void 0,
+      refundTxSigningJob: void 0,
       directRefundTxSigningJob: void 0,
-      directFromCpfpRefundTxSigningJob: void 0
+      directFromCpfpRefundTxSigningJob: void 0,
+      children: []
     };
-    const tx = new Transaction7({ version: 3 });
-    tx.addInput({
-      txid: getTxId(parentTx),
-      index: vout
-    });
     const parentTxOut = parentTx.getOutput(vout);
     if (!parentTxOut?.script || !parentTxOut?.amount) {
       throw new Error("parentTxOut is undefined");
     }
-    tx.addOutput({
+    const parentOutPoint = {
+      txid: hexToBytes10(getTxId(parentTx)),
+      index: vout
+    };
+    const parentTxOutObj = {
       script: parentTxOut.script,
       amount: parentTxOut.amount
-      // maybeApplyFee(parentTxOut.amount),
-    });
-    tx.addOutput(getEphemeralAnchorOutput());
-    const signingNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const signingJob = {
+    };
+    const { cpfpNodeTx, directNodeTx } = createNodeTxs(
+      parentTxOutObj,
+      parentOutPoint
+    );
+    const cpfpNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpNodeSigningJob = {
       signingPublicKey: node.signingPublicKey,
-      rawTx: tx.toBytes(),
-      signingNonceCommitment: signingNonceCommitment.commitment
+      rawTx: cpfpNodeTx.toBytes(),
+      signingNonceCommitment: cpfpNodeSigningCommitment.commitment
     };
-    internalCreationNode.nodeTxSigningCommitment = signingNonceCommitment;
-    internalCreationNode.nodeTxSigningJob = signingJob;
-    const sequence = 1 << 30 | INITIAL_TIME_LOCK3;
+    const directNodeSigningJob = directNodeTx ? {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: directNodeTx.toBytes(),
+      signingNonceCommitment: directNodeSigningCommitment.commitment
+    } : void 0;
+    internalCreationNode.nodeTxSigningCommitment = cpfpNodeSigningCommitment;
+    internalCreationNode.directNodeTxSigningCommitment = directNodeSigningCommitment;
+    internalCreationNode.nodeTxSigningJob = cpfpNodeSigningJob;
+    internalCreationNode.directNodeTxSigningJob = directNodeSigningJob;
+    const sequence = INITIAL_SEQUENCE;
+    const directSequence = INITIAL_DIRECT_SEQUENCE;
     const childCreationNode = {
       nodeTxSigningJob: void 0,
-      refundTxSigningJob: void 0,
-      children: [],
       directNodeTxSigningJob: void 0,
+      refundTxSigningJob: void 0,
       directRefundTxSigningJob: void 0,
-      directFromCpfpRefundTxSigningJob: void 0
+      directFromCpfpRefundTxSigningJob: void 0,
+      children: []
     };
-    const childTx = new Transaction7({ version: 3 });
-    childTx.addInput({
-      txid: getTxId(tx),
-      index: 0,
-      sequence
-    });
-    childTx.addOutput({
-      script: parentTxOut.script,
-      amount: parentTxOut.amount
-      // maybeApplyFee(parentTxOut.amount),
-    });
-    childTx.addOutput(getEphemeralAnchorOutput());
-    const childSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const childSigningJob = {
+    const [cpfpLeafTx, directLeafTx] = createLeafNodeTx(
+      sequence,
+      directSequence,
+      { txid: hexToBytes10(getTxId(cpfpNodeTx)), index: 0 },
+      parentTxOutObj,
+      true
+      // shouldCalculateFee
+    );
+    const cpfpLeafSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directLeafSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpLeafSigningJob = {
       signingPublicKey: node.signingPublicKey,
-      rawTx: childTx.toBytes(),
-      signingNonceCommitment: childSigningNonceCommitment.commitment
+      rawTx: cpfpLeafTx.toBytes(),
+      signingNonceCommitment: cpfpLeafSigningCommitment.commitment
     };
-    childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
-    childCreationNode.nodeTxSigningJob = childSigningJob;
-    const refundTx = new Transaction7({ version: 3 });
-    refundTx.addInput({
-      txid: getTxId(childTx),
-      index: 0,
-      sequence
-    });
-    const refundP2trAddress = getP2TRAddressFromPublicKey(
-      node.signingPublicKey,
+    const directLeafSigningJob = {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: directLeafTx.toBytes(),
+      signingNonceCommitment: directLeafSigningCommitment.commitment
+    };
+    childCreationNode.nodeTxSigningCommitment = cpfpLeafSigningCommitment;
+    childCreationNode.directNodeTxSigningCommitment = directLeafSigningCommitment;
+    childCreationNode.nodeTxSigningJob = cpfpLeafSigningJob;
+    childCreationNode.directNodeTxSigningJob = directLeafSigningJob;
+    const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+      sequence,
+      directSequence,
+      input: { txid: hexToBytes10(getTxId(cpfpLeafTx)), index: 0 },
+      directInput: { txid: hexToBytes10(getTxId(directLeafTx)), index: 0 },
+      amountSats: parentTxOut.amount,
+      receivingPubkey: node.signingPublicKey,
       network
-    );
-    const refundAddress = Address4(getNetwork(network)).decode(
-      refundP2trAddress
-    );
-    const refundPkScript = OutScript4.encode(refundAddress);
-    refundTx.addOutput({
-      script: refundPkScript,
-      amount: maybeApplyFee2(parentTxOut.amount)
     });
-    refundTx.addOutput(getEphemeralAnchorOutput());
-    const refundSigningNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const refundSigningJob = {
+    const cpfpRefundSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directRefundSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directFromCpfpRefundSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpRefundSigningJob = {
       signingPublicKey: node.signingPublicKey,
-      rawTx: refundTx.toBytes(),
-      signingNonceCommitment: refundSigningNonceCommitment.commitment
+      rawTx: cpfpRefundTx.toBytes(),
+      signingNonceCommitment: cpfpRefundSigningCommitment.commitment
     };
-    childCreationNode.refundTxSigningCommitment = refundSigningNonceCommitment;
-    childCreationNode.refundTxSigningJob = refundSigningJob;
+    const directRefundSigningJob = directRefundTx ? {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: directRefundTx.toBytes(),
+      signingNonceCommitment: directRefundSigningCommitment.commitment
+    } : void 0;
+    const directFromCpfpRefundSigningJob = directFromCpfpRefundTx ? {
+      signingPublicKey: node.signingPublicKey,
+      rawTx: directFromCpfpRefundTx.toBytes(),
+      signingNonceCommitment: directFromCpfpRefundSigningCommitment.commitment
+    } : void 0;
+    childCreationNode.refundTxSigningCommitment = cpfpRefundSigningCommitment;
+    childCreationNode.directRefundTxSigningCommitment = directRefundSigningCommitment;
+    childCreationNode.directFromCpfpRefundTxSigningCommitment = directFromCpfpRefundSigningCommitment;
+    childCreationNode.refundTxSigningJob = cpfpRefundSigningJob;
+    childCreationNode.directRefundTxSigningJob = directRefundSigningJob;
+    childCreationNode.directFromCpfpRefundTxSigningJob = directFromCpfpRefundSigningJob;
     internalCreationNode.children.push(childCreationNode);
     return internalCreationNode;
   }
@@ -9575,40 +10700,49 @@ var TreeCreationService = class {
     if (!parentTxOutput?.script || !parentTxOutput?.amount) {
       throw new Error("parentTxOutput is undefined");
     }
-    const rootNodeTx = new Transaction7({ version: 3 });
-    rootNodeTx.addInput({
-      txid: getTxId(parentTx),
-      index: vout
-    });
+    const childTxOuts = [];
     for (let i = 0; i < root.children.length; i++) {
       const child = root.children[i];
       if (!child || !child.address) {
         throw new Error("child address is undefined");
       }
-      const childAddress = Address4(getNetwork(network)).decode(child.address);
-      const childPkScript = OutScript4.encode(childAddress);
-      rootNodeTx.addOutput({
+      const childAddress = Address3(getNetwork(network)).decode(child.address);
+      const childPkScript = OutScript3.encode(childAddress);
+      childTxOuts.push({
         script: childPkScript,
         amount: parentTxOutput.amount / 2n
-        // feeAdjustedAmount / 2n,
       });
     }
-    rootNodeTx.addOutput(getEphemeralAnchorOutput());
-    const rootNodeSigningCommitment = await this.config.signer.getRandomSigningCommitment();
-    const rootNodeSigningJob = {
+    const parentOutPoint = {
+      txid: hexToBytes10(getTxId(parentTx)),
+      index: vout
+    };
+    const [cpfpSplitTx, directSplitTx] = createSplitTx(
+      parentOutPoint,
+      childTxOuts
+    );
+    const cpfpSplitSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const directSplitSigningCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpSplitSigningJob = {
+      signingPublicKey: root.signingPublicKey,
+      rawTx: cpfpSplitTx.toBytes(),
+      signingNonceCommitment: cpfpSplitSigningCommitment.commitment
+    };
+    const directSplitSigningJob = {
       signingPublicKey: root.signingPublicKey,
-      rawTx: rootNodeTx.toBytes(),
-      signingNonceCommitment: rootNodeSigningCommitment.commitment
+      rawTx: directSplitTx.toBytes(),
+      signingNonceCommitment: directSplitSigningCommitment.commitment
     };
     const rootCreationNode = {
-      nodeTxSigningJob: rootNodeSigningJob,
+      nodeTxSigningJob: cpfpSplitSigningJob,
+      directNodeTxSigningJob: directSplitSigningJob,
       refundTxSigningJob: void 0,
-      children: [],
-      directNodeTxSigningJob: void 0,
       directRefundTxSigningJob: void 0,
-      directFromCpfpRefundTxSigningJob: void 0
+      directFromCpfpRefundTxSigningJob: void 0,
+      children: []
     };
-    rootCreationNode.nodeTxSigningCommitment = rootNodeSigningCommitment;
+    rootCreationNode.nodeTxSigningCommitment = cpfpSplitSigningCommitment;
+    rootCreationNode.directNodeTxSigningCommitment = directSplitSigningCommitment;
     const leftChild = root.children[0];
     const rightChild = root.children[1];
     if (!leftChild || !rightChild) {
@@ -9616,13 +10750,15 @@ var TreeCreationService = class {
     }
     const leftChildCreationNode = await this.buildChildCreationNode(
       leftChild,
-      rootNodeTx,
+      cpfpSplitTx,
+      // Use CPFP version for children
       0,
       network
     );
     const rightChildCreationNode = await this.buildChildCreationNode(
       rightChild,
-      rootNodeTx,
+      cpfpSplitTx,
+      // Use CPFP version for children
       1,
       network
     );
@@ -9631,19 +10767,19 @@ var TreeCreationService = class {
     return rootCreationNode;
   }
   async signNodeCreation(parentTx, vout, internalNode, creationNode, creationResponseNode) {
-    if (!creationNode.nodeTxSigningJob?.signingPublicKey || !internalNode.verificationKey) {
+    if (!creationNode.nodeTxSigningJob?.signingPublicKey || !creationNode.directNodeTxSigningJob?.signingPublicKey || !internalNode.verificationKey) {
       throw new Error("signingPublicKey or verificationKey is undefined");
     }
     const parentTxOutput = parentTx.getOutput(vout);
     if (!parentTxOutput) {
       throw new Error("parentTxOutput is undefined");
     }
-    const tx = getTxFromRawTxBytes(creationNode.nodeTxSigningJob.rawTx);
-    const txSighash = getSigHashFromTx(tx, 0, parentTxOutput);
-    let nodeTxSignature = new Uint8Array();
+    const cpfpNodeTx = getTxFromRawTxBytes(creationNode.nodeTxSigningJob.rawTx);
+    const cpfpNodeTxSighash = getSigHashFromTx(cpfpNodeTx, 0, parentTxOutput);
+    let cpfpNodeTxSignature = new Uint8Array();
     if (creationNode.nodeTxSigningCommitment) {
-      const userSignature = await this.config.signer.signFrost({
-        message: txSighash,
+      const cpfpUserSignature = await this.config.signer.signFrost({
+        message: cpfpNodeTxSighash,
         publicKey: creationNode.nodeTxSigningJob.signingPublicKey,
         keyDerivation: {
           type: "leaf" /* LEAF */,
@@ -9653,30 +10789,84 @@ var TreeCreationService = class {
         statechainCommitments: creationResponseNode.nodeTxSigningResult?.signingNonceCommitments,
         verifyingKey: internalNode.verificationKey
       });
-      nodeTxSignature = await this.config.signer.aggregateFrost({
-        message: txSighash,
+      cpfpNodeTxSignature = await this.config.signer.aggregateFrost({
+        message: cpfpNodeTxSighash,
         statechainSignatures: creationResponseNode.nodeTxSigningResult?.signatureShares,
         statechainPublicKeys: creationResponseNode.nodeTxSigningResult?.publicKeys,
         verifyingKey: internalNode.verificationKey,
         statechainCommitments: creationResponseNode.nodeTxSigningResult?.signingNonceCommitments,
         selfCommitment: creationNode.nodeTxSigningCommitment,
-        selfSignature: userSignature,
+        selfSignature: cpfpUserSignature,
+        publicKey: internalNode.signingPublicKey
+      });
+    }
+    const directNodeTx = getTxFromRawTxBytes(
+      creationNode.directNodeTxSigningJob.rawTx
+    );
+    const directNodeTxSighash = getSigHashFromTx(
+      directNodeTx,
+      0,
+      parentTxOutput
+    );
+    let directNodeTxSignature = new Uint8Array();
+    if (creationNode.directNodeTxSigningCommitment) {
+      const directUserSignature = await this.config.signer.signFrost({
+        message: directNodeTxSighash,
+        publicKey: creationNode.directNodeTxSigningJob.signingPublicKey,
+        keyDerivation: {
+          type: "leaf" /* LEAF */,
+          path: creationResponseNode.nodeId
+        },
+        selfCommitment: creationNode.directNodeTxSigningCommitment,
+        statechainCommitments: creationResponseNode.directNodeTxSigningResult?.signingNonceCommitments,
+        verifyingKey: internalNode.verificationKey
+      });
+      directNodeTxSignature = await this.config.signer.aggregateFrost({
+        message: directNodeTxSighash,
+        statechainSignatures: creationResponseNode.directNodeTxSigningResult?.signatureShares,
+        statechainPublicKeys: creationResponseNode.directNodeTxSigningResult?.publicKeys,
+        verifyingKey: internalNode.verificationKey,
+        statechainCommitments: creationResponseNode.directNodeTxSigningResult?.signingNonceCommitments,
+        selfCommitment: creationNode.directNodeTxSigningCommitment,
+        selfSignature: directUserSignature,
         publicKey: internalNode.signingPublicKey
       });
     }
-    let refundTxSignature = new Uint8Array();
-    if (creationNode.refundTxSigningCommitment) {
-      const rawTx = creationNode.refundTxSigningJob?.rawTx;
-      if (!rawTx) {
-        throw new Error("rawTx is undefined");
+    let cpfpRefundTxSignature = new Uint8Array();
+    let directRefundTxSignature = new Uint8Array();
+    let directFromCpfpRefundTxSignature = new Uint8Array();
+    if (creationNode.refundTxSigningCommitment && creationNode.directRefundTxSigningCommitment && creationNode.directFromCpfpRefundTxSigningCommitment) {
+      const rawCpfpRefundTx = creationNode.refundTxSigningJob?.rawTx;
+      const rawDirectRefundTx = creationNode.directRefundTxSigningJob?.rawTx;
+      const rawDirectFromCpfpRefundTx = creationNode.directFromCpfpRefundTxSigningJob?.rawTx;
+      if (!rawCpfpRefundTx || !rawDirectRefundTx || !rawDirectFromCpfpRefundTx) {
+        throw new Error("refund transaction rawTx is undefined");
       }
-      if (!creationNode.refundTxSigningJob?.signingPublicKey) {
-        throw new Error("signingPublicKey is undefined");
+      if (!creationNode.refundTxSigningJob?.signingPublicKey || !creationNode.directRefundTxSigningJob?.signingPublicKey || !creationNode.directFromCpfpRefundTxSigningJob?.signingPublicKey) {
+        throw new Error("refund transaction signingPublicKey is undefined");
       }
-      const refundTx = getTxFromRawTxBytes(rawTx);
-      const refundTxSighash = getSigHashFromTx(refundTx, 0, parentTxOutput);
-      const refundSigningResponse = await this.config.signer.signFrost({
-        message: refundTxSighash,
+      const cpfpRefundTx = getTxFromRawTxBytes(rawCpfpRefundTx);
+      const directRefundTx = getTxFromRawTxBytes(rawDirectRefundTx);
+      const directFromCpfpRefundTx = getTxFromRawTxBytes(
+        rawDirectFromCpfpRefundTx
+      );
+      const cpfpRefundTxSighash = getSigHashFromTx(
+        cpfpRefundTx,
+        0,
+        cpfpNodeTx.getOutput(0)
+      );
+      const directRefundTxSighash = getSigHashFromTx(
+        directRefundTx,
+        0,
+        directNodeTx.getOutput(0)
+      );
+      const directFromCpfpRefundTxSighash = getSigHashFromTx(
+        directFromCpfpRefundTx,
+        0,
+        cpfpNodeTx.getOutput(0)
+      );
+      const cpfpRefundUserSignature = await this.config.signer.signFrost({
+        message: cpfpRefundTxSighash,
         publicKey: creationNode.refundTxSigningJob.signingPublicKey,
         keyDerivation: {
           type: "leaf" /* LEAF */,
@@ -9686,27 +10876,69 @@ var TreeCreationService = class {
         statechainCommitments: creationResponseNode.refundTxSigningResult?.signingNonceCommitments,
         verifyingKey: internalNode.verificationKey
       });
-      refundTxSignature = await this.config.signer.aggregateFrost({
-        message: refundTxSighash,
+      cpfpRefundTxSignature = await this.config.signer.aggregateFrost({
+        message: cpfpRefundTxSighash,
         statechainSignatures: creationResponseNode.refundTxSigningResult?.signatureShares,
         statechainPublicKeys: creationResponseNode.refundTxSigningResult?.publicKeys,
         verifyingKey: internalNode.verificationKey,
         statechainCommitments: creationResponseNode.refundTxSigningResult?.signingNonceCommitments,
         selfCommitment: creationNode.refundTxSigningCommitment,
-        selfSignature: refundSigningResponse,
+        selfSignature: cpfpRefundUserSignature,
+        publicKey: internalNode.signingPublicKey
+      });
+      const keyDerivation = {
+        type: "leaf" /* LEAF */,
+        path: creationResponseNode.nodeId
+      };
+      const directRefundUserSignature = await this.config.signer.signFrost({
+        message: directRefundTxSighash,
+        publicKey: creationNode.directRefundTxSigningJob.signingPublicKey,
+        keyDerivation,
+        selfCommitment: creationNode.directRefundTxSigningCommitment,
+        statechainCommitments: creationResponseNode.directRefundTxSigningResult?.signingNonceCommitments,
+        verifyingKey: internalNode.verificationKey
+      });
+      directRefundTxSignature = await this.config.signer.aggregateFrost({
+        message: directRefundTxSighash,
+        statechainSignatures: creationResponseNode.directRefundTxSigningResult?.signatureShares,
+        statechainPublicKeys: creationResponseNode.directRefundTxSigningResult?.publicKeys,
+        verifyingKey: internalNode.verificationKey,
+        statechainCommitments: creationResponseNode.directRefundTxSigningResult?.signingNonceCommitments,
+        selfCommitment: creationNode.directRefundTxSigningCommitment,
+        selfSignature: directRefundUserSignature,
         publicKey: internalNode.signingPublicKey
       });
+      const directFromCpfpRefundUserSignature = await this.config.signer.signFrost({
+        message: directFromCpfpRefundTxSighash,
+        publicKey: creationNode.directFromCpfpRefundTxSigningJob.signingPublicKey,
+        keyDerivation,
+        selfCommitment: creationNode.directFromCpfpRefundTxSigningCommitment,
+        statechainCommitments: creationResponseNode.directFromCpfpRefundTxSigningResult?.signingNonceCommitments,
+        verifyingKey: internalNode.verificationKey
+      });
+      directFromCpfpRefundTxSignature = await this.config.signer.aggregateFrost(
+        {
+          message: directFromCpfpRefundTxSighash,
+          statechainSignatures: creationResponseNode.directFromCpfpRefundTxSigningResult?.signatureShares,
+          statechainPublicKeys: creationResponseNode.directFromCpfpRefundTxSigningResult?.publicKeys,
+          verifyingKey: internalNode.verificationKey,
+          statechainCommitments: creationResponseNode.directFromCpfpRefundTxSigningResult?.signingNonceCommitments,
+          selfCommitment: creationNode.directFromCpfpRefundTxSigningCommitment,
+          selfSignature: directFromCpfpRefundUserSignature,
+          publicKey: internalNode.signingPublicKey
+        }
+      );
     }
     return {
-      tx,
+      tx: cpfpNodeTx,
+      // Return CPFP version for children
       signature: {
         nodeId: creationResponseNode.nodeId,
-        nodeTxSignature,
-        refundTxSignature,
-        // TODO: Add direct refund signature
-        directNodeTxSignature: new Uint8Array(),
-        directRefundTxSignature: new Uint8Array(),
-        directFromCpfpRefundTxSignature: new Uint8Array()
+        nodeTxSignature: cpfpNodeTxSignature,
+        directNodeTxSignature,
+        refundTxSignature: cpfpRefundTxSignature,
+        directRefundTxSignature,
+        directFromCpfpRefundTxSignature
       }
     };
   }
@@ -9768,8 +11000,45 @@ var SigningService = class {
   constructor(config) {
     this.config = config;
   }
-  async signRefunds(leaves, signingCommitments, receiverIdentityPubkey) {
-    const leafSigningJobs = [];
+  async signRefundsInternal(refundTx, sighash, leaf, signingCommitments) {
+    const leafSigningJobs = [];
+    const signingCommitment = await this.config.signer.getRandomSigningCommitment();
+    if (!signingCommitments) {
+      throw new ValidationError("Invalid signing commitments", {
+        field: "signingNonceCommitments",
+        value: signingCommitments,
+        expected: "Non-null signing commitments"
+      });
+    }
+    const signingResult = await this.config.signer.signFrost({
+      message: sighash,
+      keyDerivation: leaf.keyDerivation,
+      publicKey: await this.config.signer.getPublicKeyFromDerivation(
+        leaf.keyDerivation
+      ),
+      selfCommitment: signingCommitment,
+      statechainCommitments: signingCommitments,
+      adaptorPubKey: new Uint8Array(),
+      verifyingKey: leaf.leaf.verifyingPublicKey
+    });
+    leafSigningJobs.push({
+      leafId: leaf.leaf.id,
+      signingPublicKey: await this.config.signer.getPublicKeyFromDerivation(
+        leaf.keyDerivation
+      ),
+      rawTx: refundTx.toBytes(),
+      signingNonceCommitment: signingCommitment.commitment,
+      userSignature: signingResult,
+      signingCommitments: {
+        signingCommitments
+      }
+    });
+    return leafSigningJobs;
+  }
+  async signRefunds(leaves, receiverIdentityPubkey, cpfpSigningCommitments, directSigningCommitments, directFromCpfpSigningCommitments) {
+    const cpfpLeafSigningJobs = [];
+    const directLeafSigningJobs = [];
+    const directFromCpfpLeafSigningJobs = [];
     for (let i = 0; i < leaves.length; i++) {
       const leaf = leaves[i];
       if (!leaf?.leaf) {
@@ -9780,14 +11049,20 @@ var SigningService = class {
         });
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const nodeOutPoint = {
+      const cpfpNodeOutPoint = {
         txid: hexToBytes11(getTxId(nodeTx)),
         index: 0
       };
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-      const { nextSequence } = getNextTransactionSequence(
-        currRefundTx.getInput(0).sequence
-      );
+      const sequence = currRefundTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: currRefundTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const { nextSequence, nextDirectSequence } = getNextTransactionSequence(sequence);
       const amountSats = currRefundTx.getOutput(0).amount;
       if (amountSats === void 0) {
         throw new ValidationError("Invalid refund transaction", {
@@ -9796,48 +11071,90 @@ var SigningService = class {
           expected: "Non-null amount"
         });
       }
-      const refundTx = createRefundTx(
-        nextSequence,
-        nodeOutPoint,
-        amountSats,
-        receiverIdentityPubkey,
-        this.config.getNetwork()
-      );
-      const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
-      const signingCommitment = await this.config.signer.getRandomSigningCommitment();
-      const signingNonceCommitments = signingCommitments[i]?.signingNonceCommitments;
-      if (!signingNonceCommitments) {
-        throw new ValidationError("Invalid signing commitments", {
-          field: "signingNonceCommitments",
-          value: signingCommitments[i],
-          expected: "Non-null signing nonce commitments"
-        });
+      let directNodeTx;
+      let directNodeOutPoint;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+        directNodeOutPoint = {
+          txid: hexToBytes11(getTxId(directNodeTx)),
+          index: 0
+        };
       }
-      const signingResult = await this.config.signer.signFrost({
-        message: sighash,
-        keyDerivation: leaf.keyDerivation,
-        publicKey: await this.config.signer.getPublicKeyFromDerivation(
-          leaf.keyDerivation
-        ),
-        selfCommitment: signingCommitment,
-        statechainCommitments: signingNonceCommitments,
-        adaptorPubKey: new Uint8Array(),
-        verifyingKey: leaf.leaf.verifyingPublicKey
+      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+        sequence: nextSequence,
+        directSequence: nextDirectSequence,
+        input: cpfpNodeOutPoint,
+        directInput: directNodeOutPoint,
+        amountSats,
+        receivingPubkey: receiverIdentityPubkey,
+        network: this.config.getNetwork()
       });
-      leafSigningJobs.push({
-        leafId: leaf.leaf.id,
-        signingPublicKey: await this.config.signer.getPublicKeyFromDerivation(
-          leaf.keyDerivation
-        ),
-        rawTx: refundTx.toBytes(),
-        signingNonceCommitment: signingCommitment.commitment,
-        userSignature: signingResult,
-        signingCommitments: {
-          signingCommitments: signingNonceCommitments
+      const refundSighash = getSigHashFromTx(
+        cpfpRefundTx,
+        0,
+        nodeTx.getOutput(0)
+      );
+      const signingJobs = await this.signRefundsInternal(
+        cpfpRefundTx,
+        refundSighash,
+        leaf,
+        cpfpSigningCommitments[i]?.signingNonceCommitments
+      );
+      cpfpLeafSigningJobs.push(...signingJobs);
+      if (directRefundTx) {
+        if (!directNodeTx) {
+          throw new ValidationError(
+            "Direct node transaction undefined while direct refund transaction is defined",
+            {
+              field: "directNodeTx",
+              value: directNodeTx,
+              expected: "Non-null direct node transaction"
+            }
+          );
         }
-      });
+        const refundSighash2 = getSigHashFromTx(
+          directRefundTx,
+          0,
+          directNodeTx.getOutput(0)
+        );
+        const signingJobs2 = await this.signRefundsInternal(
+          directRefundTx,
+          refundSighash2,
+          leaf,
+          directSigningCommitments[i]?.signingNonceCommitments
+        );
+        directLeafSigningJobs.push(...signingJobs2);
+      }
+      if (directFromCpfpRefundTx) {
+        if (!directNodeTx) {
+          throw new ValidationError(
+            "Direct node transaction undefined while direct from CPFP refund transaction is defined",
+            {
+              field: "directNodeTx",
+              value: directNodeTx,
+              expected: "Non-null direct node transaction"
+            }
+          );
+        }
+        const refundSighash2 = getSigHashFromTx(
+          directFromCpfpRefundTx,
+          0,
+          nodeTx.getOutput(0)
+        );
+        const signingJobs2 = await this.signRefundsInternal(
+          directFromCpfpRefundTx,
+          refundSighash2,
+          leaf,
+          directFromCpfpSigningCommitments[i]?.signingNonceCommitments
+        );
+        directFromCpfpLeafSigningJobs.push(...signingJobs2);
+      }
     }
-    return leafSigningJobs;
+    return {
+      cpfpLeafSigningJobs,
+      directLeafSigningJobs,
+      directFromCpfpLeafSigningJobs
+    };
   }
 };
 
@@ -10077,31 +11394,37 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     }
   }
   async getLeaves(isBalanceCheck = false) {
-    const leaves = await this.queryNodes({
-      source: {
-        $case: "ownerIdentityPubkey",
-        ownerIdentityPubkey: await this.config.signer.getIdentityPublicKey()
-      },
-      includeParents: false,
-      network: NetworkToProto[this.config.getNetwork()]
-    });
+    const operatorToLeaves = /* @__PURE__ */ new Map();
+    const ownerIdentityPubkey = await this.config.signer.getIdentityPublicKey();
+    let signingOperators = Object.entries(this.config.getSigningOperators());
+    if (isBalanceCheck) {
+      signingOperators = signingOperators.filter(
+        ([id, _]) => id === this.config.getCoordinatorIdentifier()
+      );
+    }
+    await Promise.all(
+      signingOperators.map(async ([id, operator]) => {
+        const leaves2 = await this.queryNodes(
+          {
+            source: {
+              $case: "ownerIdentityPubkey",
+              ownerIdentityPubkey
+            },
+            includeParents: false,
+            network: NetworkToProto[this.config.getNetwork()]
+          },
+          operator.address
+        );
+        operatorToLeaves.set(id, leaves2);
+      })
+    );
+    const leaves = operatorToLeaves.get(
+      this.config.getCoordinatorIdentifier()
+    );
     const leavesToIgnore = /* @__PURE__ */ new Set();
     if (!isBalanceCheck) {
-      for (const [id, operator] of Object.entries(
-        this.config.getSigningOperators()
-      )) {
+      for (const [id, operatorLeaves] of operatorToLeaves) {
         if (id !== this.config.getCoordinatorIdentifier()) {
-          const operatorLeaves = await this.queryNodes(
-            {
-              source: {
-                $case: "ownerIdentityPubkey",
-                ownerIdentityPubkey: await this.config.signer.getIdentityPublicKey()
-              },
-              includeParents: false,
-              network: NetworkToProto[this.config.getNetwork()]
-            },
-            operator.address
-          );
           for (const [nodeId, leaf] of Object.entries(leaves.nodes)) {
             const operatorLeaf = operatorLeaves.nodes[nodeId];
             if (!operatorLeaf) {
@@ -10542,21 +11865,68 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         }
       }))
     );
-    const { transfer, signatureMap } = await this.transferService.startSwapSignRefund(
+    const {
+      transfer,
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap
+    } = await this.transferService.startSwapSignRefund(
       leafKeyTweaks,
       hexToBytes12(this.config.getSspIdentityPublicKey()),
       new Date(Date.now() + 2 * 60 * 1e3)
     );
     try {
       if (!transfer.leaves[0]?.leaf) {
+        console.error("[processSwapBatch] First leaf is missing");
         throw new Error("Failed to get leaf");
       }
-      const refundSignature = signatureMap.get(transfer.leaves[0].leaf.id);
-      if (!refundSignature) {
-        throw new Error("Failed to get refund signature");
+      const cpfpRefundSignature = signatureMap.get(transfer.leaves[0].leaf.id);
+      if (!cpfpRefundSignature) {
+        console.error(
+          "[processSwapBatch] Missing CPFP refund signature for first leaf"
+        );
+        throw new Error("Failed to get CPFP refund signature");
+      }
+      const directRefundSignature = directSignatureMap.get(
+        transfer.leaves[0].leaf.id
+      );
+      if (!directRefundSignature) {
+        console.error(
+          "[processSwapBatch] Missing direct refund signature for first leaf"
+        );
+        throw new Error("Failed to get direct refund signature");
+      }
+      const directFromCpfpRefundSignature = directFromCpfpSignatureMap.get(
+        transfer.leaves[0].leaf.id
+      );
+      if (!directFromCpfpRefundSignature) {
+        console.error(
+          "[processSwapBatch] Missing direct from CPFP refund signature for first leaf"
+        );
+        throw new Error("Failed to get direct from CPFP refund signature");
+      }
+      const {
+        adaptorPrivateKey: cpfpAdaptorPrivateKey,
+        adaptorSignature: cpfpAdaptorSignature
+      } = generateAdaptorFromSignature(cpfpRefundSignature);
+      let directAdaptorPrivateKey = new Uint8Array();
+      let directAdaptorSignature = new Uint8Array();
+      let directFromCpfpAdaptorPrivateKey = new Uint8Array();
+      let directFromCpfpAdaptorSignature = new Uint8Array();
+      if (directRefundSignature.length > 0) {
+        const { adaptorPrivateKey, adaptorSignature } = generateAdaptorFromSignature(directRefundSignature);
+        directAdaptorPrivateKey = adaptorPrivateKey;
+        directAdaptorSignature = adaptorSignature;
+      }
+      if (directFromCpfpRefundSignature.length > 0) {
+        const { adaptorPrivateKey, adaptorSignature } = generateAdaptorFromSignature(directFromCpfpRefundSignature);
+        directFromCpfpAdaptorPrivateKey = adaptorPrivateKey;
+        directFromCpfpAdaptorSignature = adaptorSignature;
       }
-      const { adaptorPrivateKey, adaptorSignature } = generateAdaptorFromSignature(refundSignature);
       if (!transfer.leaves[0].leaf) {
+        console.error(
+          "[processSwapBatch] First leaf missing when preparing user leaves"
+        );
         throw new Error("Failed to get leaf");
       }
       const userLeaves = [];
@@ -10565,37 +11935,113 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         raw_unsigned_refund_transaction: bytesToHex11(
           transfer.leaves[0].intermediateRefundTx
         ),
-        adaptor_added_signature: bytesToHex11(adaptorSignature)
+        direct_raw_unsigned_refund_transaction: bytesToHex11(
+          transfer.leaves[0].intermediateDirectRefundTx
+        ),
+        direct_from_cpfp_raw_unsigned_refund_transaction: bytesToHex11(
+          transfer.leaves[0].intermediateDirectFromCpfpRefundTx
+        ),
+        adaptor_added_signature: bytesToHex11(cpfpAdaptorSignature),
+        direct_adaptor_added_signature: bytesToHex11(directAdaptorSignature),
+        direct_from_cpfp_adaptor_added_signature: bytesToHex11(
+          directFromCpfpAdaptorSignature
+        )
       });
       for (let i = 1; i < transfer.leaves.length; i++) {
         const leaf = transfer.leaves[i];
         if (!leaf?.leaf) {
+          console.error(`[processSwapBatch] Leaf ${i + 1} is missing`);
           throw new Error("Failed to get leaf");
         }
-        const refundSignature2 = signatureMap.get(leaf.leaf.id);
-        if (!refundSignature2) {
-          throw new Error("Failed to get refund signature");
+        const cpfpRefundSignature2 = signatureMap.get(leaf.leaf.id);
+        if (!cpfpRefundSignature2) {
+          console.error(
+            `[processSwapBatch] Missing CPFP refund signature for leaf ${i + 1}`
+          );
+          throw new Error("Failed to get CPFP refund signature");
+        }
+        const directRefundSignature2 = directSignatureMap.get(leaf.leaf.id);
+        if (!directRefundSignature2) {
+          console.error(
+            `[processSwapBatch] Missing direct refund signature for leaf ${i + 1}`
+          );
+          throw new Error("Failed to get direct refund signature");
+        }
+        const directFromCpfpRefundSignature2 = directFromCpfpSignatureMap.get(
+          leaf.leaf.id
+        );
+        if (!directFromCpfpRefundSignature2) {
+          console.error(
+            `[processSwapBatch] Missing direct from CPFP refund signature for leaf ${i + 1}`
+          );
+          throw new Error("Failed to get direct from CPFP refund signature");
         }
-        const signature = generateSignatureFromExistingAdaptor(
-          refundSignature2,
-          adaptorPrivateKey
+        const cpfpSignature = generateSignatureFromExistingAdaptor(
+          cpfpRefundSignature2,
+          cpfpAdaptorPrivateKey
         );
+        let directSignature = new Uint8Array();
+        if (directRefundSignature2.length > 0) {
+          directSignature = generateSignatureFromExistingAdaptor(
+            directRefundSignature2,
+            directAdaptorPrivateKey
+          );
+        }
+        let directFromCpfpSignature = new Uint8Array();
+        if (directFromCpfpRefundSignature2.length > 0) {
+          directFromCpfpSignature = generateSignatureFromExistingAdaptor(
+            directFromCpfpRefundSignature2,
+            directFromCpfpAdaptorPrivateKey
+          );
+        }
         userLeaves.push({
           leaf_id: leaf.leaf.id,
           raw_unsigned_refund_transaction: bytesToHex11(
             leaf.intermediateRefundTx
           ),
-          adaptor_added_signature: bytesToHex11(signature)
+          direct_raw_unsigned_refund_transaction: bytesToHex11(
+            leaf.intermediateDirectRefundTx
+          ),
+          direct_from_cpfp_raw_unsigned_refund_transaction: bytesToHex11(
+            leaf.intermediateDirectFromCpfpRefundTx
+          ),
+          adaptor_added_signature: bytesToHex11(cpfpSignature),
+          direct_adaptor_added_signature: bytesToHex11(directSignature),
+          direct_from_cpfp_adaptor_added_signature: bytesToHex11(
+            directFromCpfpSignature
+          )
         });
       }
       const sspClient = this.getSspClient();
-      const adaptorPubkey = bytesToHex11(
-        secp256k114.getPublicKey(adaptorPrivateKey)
+      const cpfpAdaptorPubkey = bytesToHex11(
+        secp256k114.getPublicKey(cpfpAdaptorPrivateKey)
       );
+      if (!cpfpAdaptorPubkey) {
+        throw new Error("Failed to generate CPFP adaptor pubkey");
+      }
+      let directAdaptorPubkey;
+      if (directAdaptorPrivateKey.length > 0) {
+        directAdaptorPubkey = bytesToHex11(
+          secp256k114.getPublicKey(directAdaptorPrivateKey)
+        );
+      }
+      let directFromCpfpAdaptorPubkey;
+      if (directFromCpfpAdaptorPrivateKey.length > 0) {
+        directFromCpfpAdaptorPubkey = bytesToHex11(
+          secp256k114.getPublicKey(directFromCpfpAdaptorPrivateKey)
+        );
+      }
       let request = null;
+      const targetAmountSats = targetAmounts?.reduce((acc, amount) => acc + amount, 0) || leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0);
+      const totalAmountSats = leavesBatch.reduce(
+        (acc, leaf) => acc + leaf.value,
+        0
+      );
       request = await sspClient.requestLeaveSwap({
         userLeaves,
-        adaptorPubkey,
+        adaptorPubkey: cpfpAdaptorPubkey,
+        directAdaptorPubkey,
+        directFromCpfpAdaptorPubkey,
         targetAmountSats: targetAmounts?.reduce((acc, amount) => acc + amount, 0) || leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0),
         totalAmountSats: leavesBatch.reduce((acc, leaf) => acc + leaf.value, 0),
         targetAmountSatsList: targetAmounts,
@@ -10604,6 +12050,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         idempotencyKey: uuidv75()
       });
       if (!request) {
+        console.error("[processSwapBatch] Leave swap request returned null");
         throw new Error("Failed to request leaves swap. No response returned.");
       }
       const nodes = await this.queryNodes({
@@ -10617,50 +12064,140 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         network: NetworkToProto[this.config.getNetwork()]
       });
       if (Object.values(nodes.nodes).length !== request.swapLeaves.length) {
+        console.error("[processSwapBatch] Node count mismatch:", {
+          actual: Object.values(nodes.nodes).length,
+          expected: request.swapLeaves.length
+        });
         throw new Error("Expected same number of nodes as swapLeaves");
       }
       for (const [nodeId, node] of Object.entries(nodes.nodes)) {
         if (!node.nodeTx) {
+          console.error(`[processSwapBatch] Node tx missing for ${nodeId}`);
           throw new Error(`Node tx not found for leaf ${nodeId}`);
         }
         if (!node.verifyingPublicKey) {
+          console.error(
+            `[processSwapBatch] Verifying public key missing for ${nodeId}`
+          );
           throw new Error(`Node public key not found for leaf ${nodeId}`);
         }
         const leaf = request.swapLeaves.find((leaf2) => leaf2.leafId === nodeId);
         if (!leaf) {
+          console.error(`[processSwapBatch] Leaf not found for node ${nodeId}`);
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
-        const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-        const refundTxBytes = hexToBytes12(leaf.rawUnsignedRefundTransaction);
-        const refundTx = getTxFromRawTxBytes(refundTxBytes);
-        const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
+        const cpfpNodeTx = getTxFromRawTxBytes(node.nodeTx);
+        const cpfpRefundTxBytes = hexToBytes12(leaf.rawUnsignedRefundTransaction);
+        const cpfpRefundTx = getTxFromRawTxBytes(cpfpRefundTxBytes);
+        const cpfpSighash = getSigHashFromTx(
+          cpfpRefundTx,
+          0,
+          cpfpNodeTx.getOutput(0)
+        );
         const nodePublicKey = node.verifyingPublicKey;
         const taprootKey = computeTaprootKeyNoScript(nodePublicKey.slice(1));
-        const adaptorSignatureBytes = hexToBytes12(leaf.adaptorSignedSignature);
+        const cpfpAdaptorSignatureBytes = hexToBytes12(
+          leaf.adaptorSignedSignature
+        );
+        applyAdaptorToSignature(
+          taprootKey.slice(1),
+          cpfpSighash,
+          cpfpAdaptorSignatureBytes,
+          cpfpAdaptorPrivateKey
+        );
+        if (!leaf.directRawUnsignedRefundTransaction) {
+          throw new Error(
+            `Direct raw unsigned refund transaction missing for node ${nodeId}`
+          );
+        }
+        if (!leaf.directAdaptorSignedSignature) {
+          throw new Error(
+            `Direct adaptor signed signature missing for node ${nodeId}`
+          );
+        }
+        const directNodeTx = getTxFromRawTxBytes(node.directTx);
+        const directRefundTxBytes = hexToBytes12(
+          leaf.directRawUnsignedRefundTransaction
+        );
+        const directRefundTx = getTxFromRawTxBytes(directRefundTxBytes);
+        const directSighash = getSigHashFromTx(
+          directRefundTx,
+          0,
+          directNodeTx.getOutput(0)
+        );
+        if (!leaf.directFromCpfpAdaptorSignedSignature) {
+          throw new Error(
+            `Direct adaptor signed signature missing for node ${nodeId}`
+          );
+        }
+        const directAdaptorSignatureBytes = hexToBytes12(
+          leaf.directAdaptorSignedSignature
+        );
+        applyAdaptorToSignature(
+          taprootKey.slice(1),
+          directSighash,
+          directAdaptorSignatureBytes,
+          directAdaptorPrivateKey
+        );
+        if (!leaf.directRawUnsignedRefundTransaction) {
+          throw new Error(
+            `Direct raw unsigned refund transaction missing for node ${nodeId}`
+          );
+        }
+        if (!leaf.directFromCpfpRawUnsignedRefundTransaction) {
+          throw new Error(
+            `Direct raw unsigned refund transaction missing for node ${nodeId}`
+          );
+        }
+        const directFromCpfpRefundTxBytes = hexToBytes12(
+          leaf.directFromCpfpRawUnsignedRefundTransaction
+        );
+        const directFromCpfpRefundTx = getTxFromRawTxBytes(
+          directFromCpfpRefundTxBytes
+        );
+        const directFromCpfpSighash = getSigHashFromTx(
+          directFromCpfpRefundTx,
+          0,
+          cpfpNodeTx.getOutput(0)
+        );
+        const directFromCpfpAdaptorSignatureBytes = hexToBytes12(
+          leaf.directFromCpfpAdaptorSignedSignature
+        );
         applyAdaptorToSignature(
           taprootKey.slice(1),
-          sighash,
-          adaptorSignatureBytes,
-          adaptorPrivateKey
+          directFromCpfpSighash,
+          directFromCpfpAdaptorSignatureBytes,
+          directFromCpfpAdaptorPrivateKey
         );
       }
       await this.transferService.deliverTransferPackage(
         transfer,
         leafKeyTweaks,
-        signatureMap
+        signatureMap,
+        directSignatureMap,
+        directFromCpfpSignatureMap
       );
       const completeResponse = await sspClient.completeLeaveSwap({
-        adaptorSecretKey: bytesToHex11(adaptorPrivateKey),
+        adaptorSecretKey: bytesToHex11(cpfpAdaptorPrivateKey),
+        directAdaptorSecretKey: bytesToHex11(directAdaptorPrivateKey),
+        directFromCpfpAdaptorSecretKey: bytesToHex11(
+          directFromCpfpAdaptorPrivateKey
+        ),
         userOutboundTransferExternalId: transfer.id,
         leavesSwapRequestId: request.id
       });
       if (!completeResponse || !completeResponse.inboundTransfer?.sparkId) {
+        console.error(
+          "[processSwapBatch] Invalid complete response:",
+          completeResponse
+        );
         throw new Error("Failed to complete leaves swap");
       }
       const incomingTransfer = await this.transferService.queryTransfer(
         completeResponse.inboundTransfer.sparkId
       );
       if (!incomingTransfer) {
+        console.error("[processSwapBatch] No incoming transfer found");
         throw new Error("Failed to get incoming transfer");
       }
       return await this.claimTransfer({
@@ -10670,6 +12207,11 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         optimize: false
       });
     } catch (e) {
+      console.error("[processSwapBatch] Error details:", {
+        error: e,
+        message: e.message,
+        stack: e.stack
+      });
       await this.cancelAllSenderInitiatedTransfers();
       throw new Error(`Failed to request leaves swap: ${e}`);
     }
@@ -10689,9 +12231,22 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const identityPublicKey = bytesToHex11(
       await this.config.signer.getIdentityPublicKey()
     );
+    const userRequests = await this.sspClient?.getTransfers(
+      transfers.transfers.map((transfer) => transfer.id)
+    );
+    const userRequestsMap = /* @__PURE__ */ new Map();
+    for (const userRequest of userRequests || []) {
+      if (userRequest && userRequest.sparkId && userRequest.userRequest) {
+        userRequestsMap.set(userRequest.sparkId, userRequest.userRequest);
+      }
+    }
     return {
       transfers: transfers.transfers.map(
-        (transfer) => mapTransferToWalletTransfer(transfer, identityPublicKey)
+        (transfer) => mapTransferToWalletTransfer(
+          transfer,
+          identityPublicKey,
+          userRequestsMap.get(transfer.id)
+        )
       ),
       offset: transfers.offset
     };
@@ -10874,7 +12429,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       network = BitcoinNetwork_default.REGTEST;
     }
     if (outputIndex === void 0) {
-      outputIndex = await this.getDepositTransactionVout(transactionId);
+      outputIndex = await this.getDepositTransactionVout({
+        txid: transactionId
+      });
     }
     const quote = await sspClient.getClaimDepositQuote({
       transactionId,
@@ -10905,7 +12462,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       throw new Error("SSP client not initialized");
     }
     if (outputIndex === void 0) {
-      outputIndex = await this.getDepositTransactionVout(transactionId);
+      outputIndex = await this.getDepositTransactionVout({
+        txid: transactionId
+      });
     }
     let network = this.config.getSspNetwork();
     if (network === BitcoinNetwork_default.FUTURE_VALUE) {
@@ -10939,25 +12498,94 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     }
     return response;
   }
+  /**
+   * Get a quote on how much credit you can claim for a deposit from the SSP. If the quote charges less fees than the max fee, claim the deposit.
+   *
+   * @param {Object} params - The parameters object
+   * @param {string} params.transactionId - The ID of the transaction
+   * @param {number} params.maxFee - The maximum fee to claim the deposit for
+   * @param {number} [params.outputIndex] - The index of the output
+   * @returns {Promise<StaticDepositQuoteOutput>} Quote for claiming a deposit to a static deposit address
+   */
+  async claimStaticDepositWithMaxFee({
+    transactionId,
+    maxFee,
+    outputIndex
+  }) {
+    const sspClient = this.getSspClient();
+    let network = this.config.getSspNetwork();
+    if (network === BitcoinNetwork_default.FUTURE_VALUE) {
+      network = BitcoinNetwork_default.REGTEST;
+    }
+    const depositTx = await this.getDepositTransaction(transactionId);
+    if (outputIndex === void 0) {
+      outputIndex = await this.getDepositTransactionVout({
+        txid: transactionId,
+        depositTx
+      });
+    }
+    const depositAmount = Number(depositTx.getOutput(outputIndex).amount);
+    const quote = await sspClient.getClaimDepositQuote({
+      transactionId,
+      outputIndex,
+      network
+    });
+    if (!quote) {
+      throw new Error("Failed to get claim deposit quote");
+    }
+    const { creditAmountSats, signature: sspSignature } = quote;
+    const feeCharged = depositAmount - creditAmountSats;
+    if (feeCharged > maxFee) {
+      throw new ValidationError("Fee larger than max fee", {
+        field: "feeCharged",
+        value: feeCharged
+      });
+    }
+    const response = await this.claimStaticDeposit({
+      transactionId,
+      creditAmountSats,
+      sspSignature,
+      outputIndex
+    });
+    if (!response) {
+      throw new Error("Failed to claim static deposit");
+    }
+    return response;
+  }
   /**
    * Refunds a static deposit to a destination address.
    *
-   * @param {string} depositTransactionId - The ID of the transaction
-   * @param {number} [outputIndex] - The index of the output
-   * @param {string} destinationAddress - The destination address
-   * @param {number} fee - The fee to refund
+   * @param {Object} params - The refund parameters
+   * @param {string} params.depositTransactionId - The ID of the transaction
+   * @param {number} [params.outputIndex] - The index of the output
+   * @param {string} params.destinationAddress - The destination address
+   * @param {number} [params.fee] - **@deprecated** The fee to refund
+   * @param {number} [params.satsPerVbyteFee] - The fee per vbyte to refund
    * @returns {Promise<string>} The hex of the refund transaction
    */
   async refundStaticDeposit({
     depositTransactionId,
     outputIndex,
     destinationAddress,
-    fee
+    fee,
+    satsPerVbyteFee
   }) {
-    if (fee <= 300) {
+    if (fee !== void 0) {
+      console.warn(
+        `refundStaticDeposit(): \`fee\` parameter is deprecated and will be removed; please switch to \`satsPerVbyteFee\`.`
+      );
+    }
+    if (fee === void 0 && satsPerVbyteFee === void 0) {
+      throw new ValidationError("Fee or satsPerVbyteFee must be provided");
+    }
+    if (satsPerVbyteFee && satsPerVbyteFee > 150) {
+      throw new ValidationError("satsPerVbyteFee must be less than 150");
+    }
+    const finalFee = satsPerVbyteFee ? satsPerVbyteFee * getTxEstimatedVbytesSizeByNumberOfInputsOutputs(1, 1) : fee;
+    if (finalFee <= 200) {
       throw new ValidationError("Fee must be greater than 300", {
         field: "fee",
-        value: fee
+        value: finalFee
       });
     }
     let network = this.config.getNetwork();
@@ -10965,10 +12593,13 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const networkJSON = networkToJSON(networkType);
     const depositTx = await this.getDepositTransaction(depositTransactionId);
     if (outputIndex === void 0) {
-      outputIndex = await this.getDepositTransactionVout(depositTransactionId);
+      outputIndex = await this.getDepositTransactionVout({
+        txid: depositTransactionId,
+        depositTx
+      });
     }
     const totalAmount = depositTx.getOutput(outputIndex).amount;
-    const creditAmountSats = Number(totalAmount) - fee;
+    const creditAmountSats = Number(totalAmount) - finalFee;
     if (creditAmountSats <= 0) {
       throw new ValidationError(
         "Fee too large. Credit amount must be greater than 0",
@@ -10984,10 +12615,10 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       index: outputIndex,
       witnessScript: new Uint8Array()
     });
-    const addressDecoded = Address5(getNetwork(network)).decode(
+    const addressDecoded = Address4(getNetwork(network)).decode(
       destinationAddress
     );
-    const outputScript = OutScript5.encode(addressDecoded);
+    const outputScript = OutScript4.encode(addressDecoded);
     tx.addOutput({
       script: outputScript,
       amount: BigInt(creditAmountSats)
@@ -11016,26 +12647,14 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const transferId = uuidv75();
-    const swapResponse = await sparkClient.initiate_utxo_swap({
+    const swapResponse = await sparkClient.initiate_static_deposit_utxo_refund({
       onChainUtxo: {
         txid: hexToBytes12(depositTransactionId),
         vout: outputIndex,
         network: networkType
       },
-      requestType: 2 /* Refund */,
-      amount: {
-        creditAmountSats: 0,
-        $case: "creditAmountSats"
-      },
       userSignature: swapResponseUserSignature,
-      sspSignature: new Uint8Array(),
-      transfer: {
-        transferId,
-        ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        receiverIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
-      },
-      spendTxSigningJob: signingJob
+      refundTxSigningJob: signingJob
     });
     if (!swapResponse) {
       throw new Error("Failed to initiate utxo swap");
@@ -11048,15 +12667,15 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         path: 0
       },
       selfCommitment: signingNonceCommitment,
-      statechainCommitments: swapResponse.spendTxSigningResult.signingNonceCommitments,
+      statechainCommitments: swapResponse.refundTxSigningResult.signingNonceCommitments,
       verifyingKey: swapResponse.depositAddress.verifyingPublicKey
     });
     const signatureResult = await this.config.signer.aggregateFrost({
       message: spendTxSighash,
-      statechainSignatures: swapResponse.spendTxSigningResult.signatureShares,
-      statechainPublicKeys: swapResponse.spendTxSigningResult.publicKeys,
+      statechainSignatures: swapResponse.refundTxSigningResult.signatureShares,
+      statechainPublicKeys: swapResponse.refundTxSigningResult.publicKeys,
       verifyingKey: swapResponse.depositAddress.verifyingPublicKey,
-      statechainCommitments: swapResponse.spendTxSigningResult.signingNonceCommitments,
+      statechainCommitments: swapResponse.refundTxSigningResult.signingNonceCommitments,
       selfCommitment: signingNonceCommitment,
       publicKey: await this.config.signer.getStaticDepositSigningKey(0),
       selfSignature: userSignature
@@ -11109,8 +12728,13 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     }
     return payload;
   }
-  async getDepositTransactionVout(txid) {
-    const depositTx = await this.getDepositTransaction(txid);
+  async getDepositTransactionVout({
+    txid,
+    depositTx
+  }) {
+    if (!depositTx) {
+      depositTx = await this.getDepositTransaction(txid);
+    }
     const staticDepositAddresses = new Set(
       await this.queryStaticDepositAddresses()
     );
@@ -11120,8 +12744,8 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       if (!output) {
         continue;
       }
-      const parsedScript = OutScript5.decode(output.script);
-      const address2 = Address5(getNetwork(this.config.getNetwork())).encode(
+      const parsedScript = OutScript4.decode(output.script);
+      const address2 = Address4(getNetwork(this.config.getNetwork())).encode(
         parsedScript
       );
       if (staticDepositAddresses.has(address2)) {
@@ -11140,8 +12764,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         field: "txid"
       });
     }
+    const { fetch: fetch2, Headers: Headers2 } = getFetch();
     const baseUrl = this.config.getElectrsUrl();
-    const headers = {};
+    const headers = new Headers2();
     let txHex;
     if (this.config.getNetwork() === 4 /* LOCAL */) {
       const localFaucet = BitcoinFaucet.getInstance();
@@ -11152,9 +12777,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         const auth = btoa(
           `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
         );
-        headers["Authorization"] = `Basic ${auth}`;
+        headers.set("Authorization", `Basic ${auth}`);
       }
-      const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
+      const response = await fetch2(`${baseUrl}/tx/${txid}/hex`, {
         headers
       });
       txHex = await response.text();
@@ -11282,8 +12907,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       this.mutexes.set(txid, mutex);
     }
     const nodes = await mutex.runExclusive(async () => {
+      const { fetch: fetch2, Headers: Headers2 } = getFetch();
       const baseUrl = this.config.getElectrsUrl();
-      const headers = {};
+      const headers = new Headers2();
       let txHex;
       if (this.config.getNetwork() === 4 /* LOCAL */) {
         const localFaucet = BitcoinFaucet.getInstance();
@@ -11294,9 +12920,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
           const auth = btoa(
             `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
           );
-          headers["Authorization"] = `Basic ${auth}`;
+          headers.set("Authorization", `Basic ${auth}`);
         }
-        const response = await fetch(`${baseUrl}/tx/${txid}/hex`, {
+        const response = await fetch2(`${baseUrl}/tx/${txid}/hex`, {
           headers
         });
         txHex = await response.text();
@@ -11324,8 +12950,8 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         if (!output) {
           continue;
         }
-        const parsedScript = OutScript5.decode(output.script);
-        const address2 = Address5(getNetwork(this.config.getNetwork())).encode(
+        const parsedScript = OutScript4.decode(output.script);
+        const address2 = Address4(getNetwork(this.config.getNetwork())).encode(
           parsedScript
         );
         if (unusedDepositAddresses.has(address2)) {
@@ -11385,8 +13011,8 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       if (!output) {
         continue;
       }
-      const parsedScript = OutScript5.decode(output.script);
-      const address2 = Address5(getNetwork(this.config.getNetwork())).encode(
+      const parsedScript = OutScript4.decode(output.script);
+      const address2 = Address4(getNetwork(this.config.getNetwork())).encode(
         parsedScript
       );
       const unusedDepositAddress = unusedDepositAddresses.get(address2);
@@ -11538,10 +13164,16 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const validNodes = [];
     for (const node of nodes) {
       const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-      const { needRefresh } = getNextTransactionSequence(
-        nodeTx.getInput(0).sequence
-      );
-      if (needRefresh) {
+      const sequence = nodeTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid node transaction", {
+          field: "sequence",
+          value: nodeTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const needsRefresh = doesLeafNeedRefresh(sequence, true);
+      if (needsRefresh) {
         nodesToExtend.push(node);
         nodeIds.push(node.id);
       } else {
@@ -11578,11 +13210,16 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     const validNodes = [];
     for (const node of nodes) {
       const refundTx = getTxFromRawTxBytes(node.refundTx);
-      const { needRefresh } = getNextTransactionSequence(
-        refundTx.getInput(0).sequence,
-        true
-      );
-      if (needRefresh) {
+      const sequence = refundTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: refundTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const needsRefresh = doesLeafNeedRefresh(sequence);
+      if (needsRefresh) {
         nodesToRefresh.push(node);
         nodeIds.push(node.id);
       } else {
@@ -11616,7 +13253,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         throw new Error(`parent node ${node.parentNodeId} not found`);
       }
       const { nodes: nodes2 } = await this.transferService.refreshTimelockNodes(
-        [node],
+        node,
         parentNode
       );
       if (nodes2.length !== 1) {
@@ -11665,7 +13302,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
               leavesToClaim.push({
                 leaf: {
                   ...leaf.leaf,
-                  refundTx: leaf.intermediateRefundTx
+                  refundTx: leaf.intermediateRefundTx,
+                  directRefundTx: leaf.intermediateDirectRefundTx,
+                  directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx
                 },
                 keyDerivation: {
                   type: "ecies" /* ECIES */,
@@ -11741,7 +13380,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       if (type && transfer.type !== type) {
         continue;
       }
-      if (transfer.status !== 2 /* TRANSFER_STATUS_SENDER_KEY_TWEAKED */ && transfer.status !== 3 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAKED */ && transfer.status !== 4 /* TRANSFER_STATUS_RECEIVER_REFUND_SIGNED */ && transfer.status !== 10 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAK_APPLIED */) {
+      if (transfer.status !== 2 /* TRANSFER_STATUS_SENDER_KEY_TWEAKED */ && transfer.status !== 3 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAKED */ && transfer.status !== 4 /* TRANSFER_STATUS_RECEIVER_REFUND_SIGNED */ && transfer.status !== 10 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAK_APPLIED */ && transfer.status !== 9 /* TRANSFER_STATUS_RECEIVER_KEY_TWEAK_LOCKED */) {
         continue;
       }
       promises.push(
@@ -12029,6 +13668,8 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       await this.transferService.deliverTransferPackage(
         swapResponse.transfer,
         leavesToSend,
+        /* @__PURE__ */ new Map(),
+        /* @__PURE__ */ new Map(),
         /* @__PURE__ */ new Map()
       );
       const sspResponse = await sspClient.requestLightningSend({
@@ -12308,11 +13949,12 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
    * Gets a transfer that has been sent by the SSP to the wallet.
    *
    * @param {string} id - The ID of the transfer
-   * @returns {Promise<GraphQLTransferObj | null>} The transfer
+   * @returns {Promise<TransferWithUserRequest | undefined>} The transfer
    */
   async getTransferFromSsp(id) {
     const sspClient = this.getSspClient();
-    return await sspClient.getTransfer(id);
+    const transfers = await sspClient.getTransfers([id]);
+    return transfers?.[0];
   }
   /**
    * Gets a transfer, that the wallet is a participant of, in the Spark network.
@@ -12791,87 +14433,64 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         },
         includeParents: true
       });
-      const node = response.nodes[nodeId];
-      if (!node) {
+      let leaf = response.nodes[nodeId];
+      if (!leaf) {
         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 result = await this.transferService.refreshTimelockNodes(
-        [node],
-        parentNode
-      );
-      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;
+      let parentNode;
+      let hasParentNode = false;
+      if (!leaf.parentNodeId) {
+      } else {
+        hasParentNode = true;
+        parentNode = response.nodes[leaf.parentNodeId];
+        if (!parentNode) {
+          throw new ValidationError("Parent node not found", {
+            field: "parentNodeId",
+            value: leaf.parentNodeId
+          });
         }
       }
-    } 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]
+      const nodeTx = getTxFromRawTxBytes(leaf.nodeTx);
+      const refundTx = getTxFromRawTxBytes(leaf.refundTx);
+      if (hasParentNode) {
+        const nodeTimelock = getCurrentTimelock(nodeTx.getInput(0).sequence);
+        if (nodeTimelock > 100) {
+          const expiredNodeTxLeaf = await this.transferService.testonly_expireTimeLockNodeTx(
+            leaf,
+            parentNode
+          );
+          if (!expiredNodeTxLeaf.nodes[0]) {
+            throw new ValidationError("No expired node tx leaf", {
+              field: "expiredNodeTxLeaf",
+              value: expiredNodeTxLeaf
+            });
           }
-        },
-        includeParents: false
-      });
-      const node = response.nodes[nodeId];
-      if (!node) {
-        throw new ValidationError("Node not found", {
-          field: "nodeId",
-          value: nodeId
-        });
+          leaf = expiredNodeTxLeaf.nodes[0];
+        }
       }
-      const result = await this.transferService.refreshTimelockRefundTx(node);
-      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;
+      const refundTimelock = getCurrentTimelock(refundTx.getInput(0).sequence);
+      if (refundTimelock > 100) {
+        const expiredTxLeaf = await this.transferService.testonly_expireTimeLockRefundtx(leaf);
+        if (!expiredTxLeaf.nodes[0]) {
+          throw new ValidationError("No expired tx leaf", {
+            field: "expiredTxLeaf",
+            value: expiredTxLeaf
+          });
         }
+        leaf = expiredTxLeaf.nodes[0];
+      }
+      const leafIndex = this.leaves.findIndex((leaf2) => leaf2.id === leaf2.id);
+      if (leafIndex !== -1) {
+        this.leaves[leafIndex] = leaf;
       }
     } catch (error) {
       throw new NetworkError(
-        "Failed to refresh refund timelock",
+        "Failed to refresh timelock",
         {
-          method: "refresh_timelock_refund_tx"
+          method: "refresh_timelock"
         },
         error
       );
@@ -12933,16 +14552,17 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
 
 // src/utils/mempool.ts
 async function getLatestDepositTxId(address2) {
+  const { fetch: fetch2, Headers: Headers2 } = getFetch();
   const network = getNetworkFromAddress(address2);
   const baseUrl = network === BitcoinNetwork_default.REGTEST ? getElectrsUrl("REGTEST") : getElectrsUrl("MAINNET");
-  const headers = {};
+  const headers = new Headers2();
   if (network === BitcoinNetwork_default.REGTEST) {
     const auth = btoa(
       `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
     );
-    headers["Authorization"] = `Basic ${auth}`;
+    headers.set("Authorization", `Basic ${auth}`);
   }
-  const response = await fetch(`${baseUrl}/address/${address2}/txs`, {
+  const response = await fetch2(`${baseUrl}/address/${address2}/txs`, {
     headers
   });
   const addressTxs = await response.json();
@@ -12959,14 +14579,15 @@ async function getLatestDepositTxId(address2) {
   return null;
 }
 async function isTxBroadcast(txid, baseUrl, network) {
-  const headers = {};
+  const { fetch: fetch2, Headers: Headers2 } = getFetch();
+  const headers = new Headers2();
   if (network === 3 /* REGTEST */) {
     const auth = btoa(
       `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
     );
-    headers["Authorization"] = `Basic ${auth}`;
+    headers.set("Authorization", `Basic ${auth}`);
   }
-  const response = await fetch(`${baseUrl}/tx/${txid}`, {
+  const response = await fetch2(`${baseUrl}/tx/${txid}`, {
     headers
   });
   const tx = await response.json();
@@ -12980,7 +14601,7 @@ async function isTxBroadcast(txid, baseUrl, network) {
 import { bytesToHex as bytesToHex12, hexToBytes as hexToBytes13 } from "@noble/curves/abstract/utils";
 import { ripemd160 } from "@noble/hashes/legacy";
 import { sha256 as sha25612 } from "@noble/hashes/sha2";
-import * as btc5 from "@scure/btc-signer";
+import * as btc4 from "@scure/btc-signer";
 function isEphemeralAnchorOutput(script, amount) {
   return Boolean(
     amount === 0n && script && // Pattern 1: Bare OP_TRUE (single byte 0x51)
@@ -13195,7 +14816,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         usedUtxos,
         correctedParentTx
       } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
-      const feeBumpTx = btc5.Transaction.fromPSBT(hexToBytes13(nodeFeeBumpPsbt));
+      const feeBumpTx = btc4.Transaction.fromPSBT(hexToBytes13(nodeFeeBumpPsbt));
       var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
       var feeBumpOutPubKey = null;
       for (const usedUtxo of usedUtxos) {
@@ -13249,7 +14870,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           feeRate,
           void 0
         );
-        const feeBumpTx2 = btc5.Transaction.fromPSBT(
+        const feeBumpTx2 = btc4.Transaction.fromPSBT(
           hexToBytes13(refundFeeBump.feeBumpPsbt)
         );
         var feeBumpOut = feeBumpTx2.outputsLength === 1 ? feeBumpTx2.getOutput(0) : null;
@@ -13353,7 +14974,7 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
   if (utxos.length === 0) {
     throw new Error("No UTXOs available for fee bump");
   }
-  const builder = new btc5.Transaction({
+  const builder = new btc4.Transaction({
     version: 3,
     allowUnknown: true,
     allowLegacyWitnessUtxo: true
@@ -13445,19 +15066,19 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
 }
 
 // src/utils/xchain-address.ts
-import * as btc6 from "@scure/btc-signer";
+import * as btc5 from "@scure/btc-signer";
 var networkByType = {
-  MAINNET: btc6.NETWORK,
-  TESTNET: btc6.TEST_NETWORK,
+  MAINNET: btc5.NETWORK,
+  TESTNET: btc5.TEST_NETWORK,
   REGTEST: {
-    ...btc6.TEST_NETWORK,
+    ...btc5.TEST_NETWORK,
     bech32: "bcrt"
   }
 };
 function getSparkAddressFromTaproot(taprootAddress) {
   for (const networkType of ["MAINNET", "TESTNET", "REGTEST"]) {
     try {
-      const result = btc6.Address(networkByType[networkType]).decode(taprootAddress);
+      const result = btc5.Address(networkByType[networkType]).decode(taprootAddress);
       if (result.type === "tr") {
         const outputPublicKey = result.pubkey;
         return encodeSparkAddress({
@@ -13478,10 +15099,15 @@ function getSparkAddressFromTaproot(taprootAddress) {
 var utils_exports = {};
 __export(utils_exports, {
   DEFAULT_FEE_SATS: () => DEFAULT_FEE_SATS,
+  DIRECT_TIMELOCK_OFFSET: () => DIRECT_TIMELOCK_OFFSET,
+  INITIAL_DIRECT_SEQUENCE: () => INITIAL_DIRECT_SEQUENCE,
+  INITIAL_SEQUENCE: () => INITIAL_SEQUENCE,
   LRC_WALLET_NETWORK: () => LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE: () => LRC_WALLET_NETWORK_TYPE,
   Network: () => Network2,
   NetworkToProto: () => NetworkToProto,
+  TEST_UNILATERAL_DIRECT_SEQUENCE: () => TEST_UNILATERAL_DIRECT_SEQUENCE,
+  TEST_UNILATERAL_SEQUENCE: () => TEST_UNILATERAL_SEQUENCE,
   addPrivateKeys: () => addPrivateKeys,
   addPublicKeys: () => addPublicKeys,
   applyAdaptorToSignature: () => applyAdaptorToSignature,
@@ -13495,13 +15121,21 @@ __export(utils_exports, {
   constructFeeBumpTx: () => constructFeeBumpTx,
   constructUnilateralExitFeeBumpPackages: () => constructUnilateralExitFeeBumpPackages,
   constructUnilateralExitTxs: () => constructUnilateralExitTxs,
+  createConnectorRefundTransactions: () => createConnectorRefundTransactions,
+  createLeafNodeTx: () => createLeafNodeTx,
+  createNodeTx: () => createNodeTx,
+  createNodeTxs: () => createNodeTxs,
   createRefundTx: () => createRefundTx,
+  createRefundTxs: () => createRefundTxs,
+  createRootTx: () => createRootTx,
   createSigningCommitment: () => createSigningCommitment,
   createSigningNonce: () => createSigningNonce,
+  createSplitTx: () => createSplitTx,
   decodeBech32mTokenIdentifier: () => decodeBech32mTokenIdentifier,
   decodeBytesToSigningCommitment: () => decodeBytesToSigningCommitment,
   decodeBytesToSigningNonce: () => decodeBytesToSigningNonce,
   decodeSparkAddress: () => decodeSparkAddress,
+  doesLeafNeedRefresh: () => doesLeafNeedRefresh,
   encodeBech32mTokenIdentifier: () => encodeBech32mTokenIdentifier,
   encodeSigningCommitmentToBytes: () => encodeSigningCommitmentToBytes,
   encodeSigningNonceToBytes: () => encodeSigningNonceToBytes,
@@ -13530,6 +15164,7 @@ __export(utils_exports, {
   getSparkAddressFromTaproot: () => getSparkAddressFromTaproot,
   getTransactionSequence: () => getTransactionSequence,
   getTransferPackageSigningPayload: () => getTransferPackageSigningPayload,
+  getTxEstimatedVbytesSizeByNumberOfInputsOutputs: () => getTxEstimatedVbytesSizeByNumberOfInputsOutputs,
   getTxFromRawTxBytes: () => getTxFromRawTxBytes,
   getTxFromRawTxHex: () => getTxFromRawTxHex,
   getTxId: () => getTxId,
@@ -13617,12 +15252,26 @@ export {
   getSigHashFromTx,
   getTxId,
   getTxIdNoReverse,
+  getTxEstimatedVbytesSizeByNumberOfInputsOutputs,
+  DIRECT_TIMELOCK_OFFSET,
+  INITIAL_SEQUENCE,
+  INITIAL_DIRECT_SEQUENCE,
+  TEST_UNILATERAL_SEQUENCE,
+  TEST_UNILATERAL_DIRECT_SEQUENCE,
   DEFAULT_FEE_SATS,
   maybeApplyFee,
+  createRootTx,
+  createSplitTx,
+  createNodeTx,
+  createNodeTxs,
+  createLeafNodeTx,
   createRefundTx,
+  createRefundTxs,
+  createConnectorRefundTransactions,
   getCurrentTimelock,
   getTransactionSequence,
   checkIfValidSequence,
+  doesLeafNeedRefresh,
   getNextTransactionSequence,
   getEphemeralAnchorOutput,
   getTransferPackageSigningPayload,