@buildonspark/spark-sdk 0.2.3 → 0.2.4

package/dist/index.node.cjs

@@ -1290,7 +1290,10 @@ __export(index_node_exports, {
   AuthenticationError: () => AuthenticationError,
   ConfigurationError: () => ConfigurationError,
   DEFAULT_FEE_SATS: () => DEFAULT_FEE_SATS,
+  DIRECT_TIMELOCK_OFFSET: () => DIRECT_TIMELOCK_OFFSET,
   DefaultSparkSigner: () => DefaultSparkSigner,
+  INITIAL_DIRECT_SEQUENCE: () => INITIAL_DIRECT_SEQUENCE,
+  INITIAL_SEQUENCE: () => INITIAL_SEQUENCE,
   InternalValidationError: () => InternalValidationError,
   KeyDerivationType: () => KeyDerivationType,
   LRC_WALLET_NETWORK: () => LRC_WALLET_NETWORK,
@@ -1302,7 +1305,9 @@ __export(index_node_exports, {
   NotImplementedError: () => NotImplementedError,
   RPCError: () => RPCError,
   SparkSDKError: () => SparkSDKError,
-  SparkWallet: () => SparkWallet,
+  SparkWallet: () => SparkWallet2,
+  TEST_UNILATERAL_DIRECT_SEQUENCE: () => TEST_UNILATERAL_DIRECT_SEQUENCE,
+  TEST_UNILATERAL_SEQUENCE: () => TEST_UNILATERAL_SEQUENCE,
   TaprootOutputKeysGenerator: () => TaprootOutputKeysGenerator,
   TaprootSparkSigner: () => TaprootSparkSigner,
   TokenTransactionService: () => TokenTransactionService,
@@ -1322,13 +1327,21 @@ __export(index_node_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,
@@ -16204,13 +16217,24 @@ function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes
   const adaptorPrivateKey = (0, import_utils4.bytesToNumberBE)(adaptorPrivateKeyBytes);
   const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k12.secp256k1.CURVE.n);
   const newSig = new Uint8Array([...r, ...(0, import_utils4.numberToBytesBE)(newS, 32)]);
-  if (import_secp256k12.schnorr.verify(newSig, hash, pubkey)) {
-    return newSig;
+  try {
+    if (import_secp256k12.schnorr.verify(newSig, hash, pubkey)) {
+      return newSig;
+    }
+  } catch (e) {
+    console.error("[applyAdaptorToSignature] Addition verification failed:", e);
   }
   const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k12.secp256k1.CURVE.n);
   const altSig = new Uint8Array([...r, ...(0, import_utils4.numberToBytesBE)(altS, 32)]);
-  if (import_secp256k12.schnorr.verify(altSig, hash, pubkey)) {
-    return altSig;
+  try {
+    if (import_secp256k12.schnorr.verify(altSig, hash, pubkey)) {
+      return altSig;
+    }
+  } catch (e) {
+    console.error(
+      "[applyAdaptorToSignature] Subtraction verification failed:",
+      e
+    );
   }
   throw new Error("Cannot apply adaptor to signature");
 }
@@ -17104,7 +17128,11 @@ var SwapLeafFromJson = (obj) => {
   return {
     leafId: obj["swap_leaf_leaf_id"],
     rawUnsignedRefundTransaction: obj["swap_leaf_raw_unsigned_refund_transaction"],
-    adaptorSignedSignature: obj["swap_leaf_adaptor_signed_signature"]
+    adaptorSignedSignature: obj["swap_leaf_adaptor_signed_signature"],
+    directRawUnsignedRefundTransaction: obj["swap_leaf_direct_raw_unsigned_refund_transaction"],
+    directAdaptorSignedSignature: obj["swap_leaf_direct_adaptor_signed_signature"],
+    directFromCpfpRawUnsignedRefundTransaction: obj["swap_leaf_direct_from_cpfp_raw_unsigned_refund_transaction"],
+    directFromCpfpAdaptorSignedSignature: obj["swap_leaf_direct_from_cpfp_adaptor_signed_signature"]
   };
 };
 
@@ -17359,6 +17387,10 @@ fragment LeavesSwapRequestFragment on LeavesSwapRequest {
         swap_leaf_leaf_id: leaf_id
         swap_leaf_raw_unsigned_refund_transaction: raw_unsigned_refund_transaction
         swap_leaf_adaptor_signed_signature: adaptor_signed_signature
+        swap_leaf_direct_raw_unsigned_refund_transaction: direct_raw_unsigned_refund_transaction
+        swap_leaf_direct_adaptor_signed_signature: direct_adaptor_signed_signature
+        swap_leaf_direct_from_cpfp_raw_unsigned_refund_transaction: direct_from_cpfp_raw_unsigned_refund_transaction
+        swap_leaf_direct_from_cpfp_adaptor_signed_signature: direct_from_cpfp_adaptor_signed_signature
     }
 }`;
 
@@ -17705,6 +17737,10 @@ fragment UserRequestFragment on UserRequest {
             swap_leaf_leaf_id: leaf_id
             swap_leaf_raw_unsigned_refund_transaction: raw_unsigned_refund_transaction
             swap_leaf_adaptor_signed_signature: adaptor_signed_signature
+            swap_leaf_direct_raw_unsigned_refund_transaction: direct_raw_unsigned_refund_transaction
+            swap_leaf_direct_adaptor_signed_signature: direct_adaptor_signed_signature
+            swap_leaf_direct_from_cpfp_raw_unsigned_refund_transaction: direct_from_cpfp_raw_unsigned_refund_transaction
+            swap_leaf_direct_from_cpfp_adaptor_signed_signature: direct_from_cpfp_adaptor_signed_signature
         }
     }
     ... on LightningReceiveRequest {
@@ -17830,18 +17866,40 @@ function mapTransferToWalletTransfer(proto, identityPublicKey) {
   };
 }
 
+// src/utils/fetch.ts
+init_buffer();
+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/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();
@@ -17858,14 +17916,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();
@@ -18336,7 +18395,14 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
 // src/utils/transaction.ts
 init_buffer();
 var import_btc_signer = require("@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;
@@ -18346,29 +18412,270 @@ function maybeApplyFee(amount) {
   }
   return amount;
 }
-function createRefundTx(sequence, nodeOutPoint, amountSats, receivingPubkey, network) {
-  const newRefundTx = new import_btc_signer.Transaction({
+function createRootTx(depositOutPoint, depositTxOut) {
+  const cpfpRootTx = new import_btc_signer.Transaction({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpRootTx.addInput(depositOutPoint);
+  cpfpRootTx.addOutput(depositTxOut);
+  cpfpRootTx.addOutput(getEphemeralAnchorOutput());
+  const directRootTx = new import_btc_signer.Transaction({
+    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 import_btc_signer.Transaction({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpSplitTx.addInput(parentOutPoint);
+  for (const txOut of childTxOuts) {
+    cpfpSplitTx.addOutput(txOut);
+  }
+  cpfpSplitTx.addOutput(getEphemeralAnchorOutput());
+  const directSplitTx = new import_btc_signer.Transaction({
+    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 import_btc_signer.Transaction({
+    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 import_btc_signer.Transaction({
+    version: 3,
+    allowUnknownOutputs: true
+  });
+  cpfpLeafTx.addInput({
+    ...parentOutPoint,
+    sequence
+  });
+  cpfpLeafTx.addOutput(txOut);
+  cpfpLeafTx.addOutput(getEphemeralAnchorOutput());
+  const directLeafTx = new import_btc_signer.Transaction({
+    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 import_btc_signer.Transaction({
     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 import_btc_signer.Transaction({
+    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 import_btc_signer.Transaction({
+    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 import_btc_signer.Transaction({
+    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;
@@ -18386,24 +18693,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() {
@@ -18932,7 +19247,7 @@ init_buffer();
 var import_core8 = require("@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.4" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -19481,6 +19796,9 @@ var TaprootSparkSigner = class extends DefaultSparkSigner {
   }
 };
 
+// src/spark-wallet/spark-wallet.node.ts
+init_buffer();
+
 // src/spark-wallet/spark-wallet.ts
 init_buffer();
 var import_core12 = require("@lightsparkdev/core");
@@ -19643,10 +19961,18 @@ init_buffer();
 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
       }
@@ -19777,6 +20103,8 @@ init_buffer();
 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!
@@ -19786,6 +20114,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
@@ -20294,6 +20624,8 @@ var SspClient = class {
   }
   async requestLeaveSwap({
     adaptorPubkey,
+    directAdaptorPubkey,
+    directFromCpfpAdaptorPubkey,
     totalAmountSats,
     targetAmountSats,
     feeSats,
@@ -20305,6 +20637,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,
@@ -20323,6 +20657,8 @@ var SspClient = class {
   }
   async completeLeaveSwap({
     adaptorSecretKey,
+    directAdaptorSecretKey,
+    directFromCpfpAdaptorSecretKey,
     userOutboundTransferExternalId,
     leavesSwapRequestId
   }) {
@@ -20330,6 +20666,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
       },
@@ -24494,11 +24832,7 @@ var import_sha28 = require("@noble/hashes/sha2");
 var import_btc_signer2 = require("@scure/btc-signer");
 var ecies2 = __toESM(require("eciesjs"), 1);
 var import_uuidv72 = require("uuidv7");
-var INITIAL_TIME_LOCK = 2e3;
 var DEFAULT_EXPIRY_TIME = 10 * 60 * 1e3;
-function initialSequence() {
-  return 1 << 30 | INITIAL_TIME_LOCK;
-}
 function getSigningJobProto(signingJob) {
   return {
     signingPublicKey: signingJob.signingPublicKey,
@@ -24515,12 +24849,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()];
@@ -24558,13 +24894,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,
@@ -24590,6 +24939,8 @@ var BaseTransferService = class {
       transferID,
       receiverIdentityPubkey,
       leaves,
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
       /* @__PURE__ */ new Map()
     );
     const transferPackage = await this.prepareTransferPackage(
@@ -24603,7 +24954,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,
@@ -24632,12 +24983,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) {
@@ -24657,12 +25018,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,
@@ -24722,7 +25082,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);
@@ -24737,54 +25097,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(
       (0, import_utils14.bytesToHex)(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, [
@@ -24795,7 +25221,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,
@@ -24843,10 +25269,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;
@@ -24876,7 +25301,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)
@@ -24884,7 +25314,9 @@ var TransferService = class extends BaseTransferService {
     const transferWithTweakedKeys = await this.sendTransferTweakKey(
       transfer,
       leaves,
-      signatureMap
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap
     );
     return transferWithTweakedKeys;
   }
@@ -24988,7 +25420,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,
@@ -24997,11 +25435,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,
@@ -25010,31 +25456,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 = (0, import_uuidv72.uuidv7)();
     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
       });
     }
@@ -25047,8 +25507,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,
@@ -25057,10 +25517,12 @@ var TransferService = class extends BaseTransferService {
             expiryTime
           },
           swapId: (0, import_uuidv72.uuidv7)(),
-          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(),
@@ -25068,7 +25530,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(),
@@ -25085,15 +25547,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
     };
@@ -25106,38 +25582,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: (0, import_utils14.hexToBytes)(getTxId(nodeTx)),
         index: 0
       };
+      let directNodeTx;
+      let directNodeOutPoint;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+        directNodeOutPoint = {
+          txid: (0, import_utils14.hexToBytes)(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;
@@ -25258,13 +25764,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
       });
     }
@@ -25286,7 +25796,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
@@ -25301,7 +25811,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
       });
@@ -25340,109 +25850,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 import_btc_signer2.Transaction({ version: 3, allowUnknownOutputs: true });
-      const originalOutput = nodeTx.getOutput(0);
-      if (!originalOutput) {
-        throw Error("Could not get original output");
-      }
-      newTx.addOutput({
-        script: originalOutput.script,
-        amount: originalOutput.amount
-      });
-      for (let j = 1; j < nodeTx.outputsLength; j++) {
-        const additionalOutput = nodeTx.getOutput(j);
-        if (additionalOutput) {
-          newTx.addOutput(additionalOutput);
-        }
-      }
-      if (i === 0) {
-        const currSequence = input.sequence;
-        newTx.addInput({
-          ...input,
-          sequence: getNextTransactionSequence(currSequence).nextSequence
-        });
-      } else {
-        newTx.addInput({
-          ...input,
-          sequence: initialSequence(),
-          txid: newNodeTxs[i - 1]?.id
-        });
-      }
-      signingJobs.push({
-        signingPublicKey: await this.config.signer.getPublicKeyFromDerivation({
-          type: "leaf" /* LEAF */,
-          path: node.id
-        }),
-        rawTx: newTx.toBytes(),
-        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
+    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"
       });
-      newNodeTxs[i] = newTx;
     }
-    const leaf = nodes[nodes.length - 1];
-    if (!leaf?.refundTx) {
-      throw Error("leaf does not have refund tx");
+    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 refundTx = getTxFromRawTxBytes(leaf?.refundTx);
-    const newRefundTx = new import_btc_signer2.Transaction({
-      version: 3,
-      allowUnknownOutputs: true
+    const newDirectNodeOutput = newDirectNodeTx?.getOutput(0);
+    const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation({
+      type: "leaf" /* LEAF */,
+      path: node.id
     });
-    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: cpfpNodeTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "node",
+      parentTxOut: parentNodeOutput
     });
-    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 (newDirectNodeTx) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: newDirectNodeTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directNode",
+        parentTxOut: parentNodeOutput
+      });
     }
-    if (!newNodeTxs[newNodeTxs.length - 1]) {
-      throw Error("Could not get last node tx");
+    const newCpfpRefundOutPoint = {
+      txid: (0, import_utils14.hexToBytes)(getTxId(cpfpNodeTx)),
+      index: 0
+    };
+    let newDirectRefundOutPoint;
+    if (newDirectNodeTx) {
+      newDirectRefundOutPoint = {
+        txid: (0, import_utils14.hexToBytes)(getTxId(newDirectNodeTx)),
+        index: 0
+      };
     }
-    newRefundTx.addInput({
-      ...refundTxInput,
-      sequence: initialSequence(),
-      txid: getTxId(newNodeTxs[newNodeTxs.length - 1])
-    });
-    const refundSigningJob = {
-      signingPublicKey: await this.config.signer.getPublicKeyFromDerivation({
+    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: leaf.id
+        path: node.id
       }),
-      rawTx: newRefundTx.toBytes(),
-      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment()
-    };
-    signingJobs.push(refundSigningJob);
+      network: this.config.getNetwork()
+    });
+    signingJobs.push({
+      signingPublicKey,
+      rawTx: cpfpRefundTx.toBytes(),
+      signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+      type: "cpfp",
+      parentTxOut: newCpfpNodeOutput
+    });
+    if (directRefundTx && newDirectNodeOutput) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: directRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "direct",
+        parentTxOut: newDirectNodeOutput
+      });
+    }
+    if (directFromCpfpRefundTx && newCpfpNodeOutput) {
+      signingJobs.push({
+        signingPublicKey,
+        rawTx: directFromCpfpRefundTx.toBytes(),
+        signingNonceCommitment: await this.config.signer.getRandomSigningCommitment(),
+        type: "directFromCpfp",
+        parentTxOut: newCpfpNodeOutput
+      });
+    }
     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)
     });
@@ -25452,45 +25987,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,
@@ -25509,41 +26026,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()
+      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({
+    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);
@@ -25552,7 +26063,10 @@ var TransferService = class extends BaseTransferService {
       txid: (0, import_utils14.hexToBytes)(getTxId(nodeTx)),
       index: 0
     };
-    const { nextSequence: newNodeSequence } = getNextTransactionSequence(refundSequence);
+    const {
+      nextSequence: newNodeSequence,
+      nextDirectSequence: newDirectNodeSequence
+    } = getNextTransactionSequence(refundSequence);
     const newNodeTx = new import_btc_signer2.Transaction({
       version: 3,
       allowUnknownOutputs: true
@@ -25565,81 +26079,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 import_btc_signer2.Transaction({
+        version: 3,
+        allowUnknownOutputs: true
+      });
+      newDirectNodeTx.addInput({
+        ...newNodeOutPoint,
+        sequence: newDirectNodeSequence
+      });
+      newDirectNodeTx.addOutput({
+        script: originalOutput.script,
+        amount: maybeApplyFee(originalOutput.amount)
+      });
+    }
+    const newCpfpRefundOutPoint = {
       txid: (0, import_utils14.hexToBytes)(getTxId(newNodeTx)),
       index: 0
     };
+    let newDirectRefundOutPoint;
+    if (newDirectNodeTx) {
+      newDirectRefundOutPoint = {
+        txid: (0, import_utils14.hexToBytes)(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,
@@ -25647,122 +26202,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 import_btc_signer2.Transaction({
-      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: (0, import_utils14.hexToBytes)(getTxId(nodeTx)),
+      index: 0
+    };
+    let directRefundOutPoint;
+    if (directNodeTx) {
+      directRefundOutPoint = {
+        txid: (0, import_utils14.hexToBytes)(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
         }
       ]
     });
@@ -25781,7 +26467,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,
@@ -25790,34 +26481,81 @@ var CoopExitService = class extends BaseTransferService {
     const transferTweak = await this.deliverTransferPackage(
       transfer,
       leaves,
-      signaturesMap
+      signaturesMap,
+      directSignaturesMap,
+      directFromCpfpSignaturesMap
     );
-    return { transfer: transferTweak, signaturesMap };
-  }
-  createConnectorRefundTransaction(sequence, nodeOutPoint, connectorOutput, amountSats, receiverPubKey) {
-    const refundTx = new import_btc_signer3.Transaction();
-    if (!nodeOutPoint.txid || nodeOutPoint.index === void 0) {
-      throw new ValidationError("Invalid node outpoint", {
-        field: "nodeOutPoint",
-        value: { txid: nodeOutPoint.txid, index: nodeOutPoint.index },
+    return {
+      transfer: transferTweak,
+      signaturesMap,
+      directSignaturesMap,
+      directFromCpfpSignaturesMap
+    };
+  }
+  createConnectorRefundTransactions(sequence, directSequence, cpfpNodeOutPoint, directNodeOutPoint, connectorOutput, amountSats, receiverPubKey) {
+    const cpfpRefundTx = new import_btc_signer3.Transaction();
+    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 import_btc_signer3.Transaction();
+      directRefundTx.addInput({
+        txid: directNodeOutPoint.txid,
+        index: directNodeOutPoint.index,
+        sequence: directSequence
+      });
+      directRefundTx.addInput(connectorOutput);
+      directRefundTx.addOutput({
+        script: receiverScript,
+        amount: maybeApplyFee(amountSats)
+      });
+      directFromCpfpRefundTx = new import_btc_signer3.Transaction();
+      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) {
@@ -25853,39 +26591,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(
@@ -25893,7 +26659,7 @@ var CoopExitService = class extends BaseTransferService {
     );
     let response;
     try {
-      response = await sparkClient.cooperative_exit({
+      response = await sparkClient.cooperative_exit_v2({
         transfer: {
           transferId: (0, import_uuidv73.uuidv7)(),
           leavesToSend: signingJobs,
@@ -25927,10 +26693,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
+    };
   }
 };
 
@@ -25939,10 +26720,8 @@ init_buffer();
 var import_secp256k110 = require("@noble/curves/secp256k1");
 var import_sha29 = require("@noble/hashes/sha2");
 var import_utils15 = require("@noble/hashes/utils");
-var btc5 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer4 = require("@scure/btc-signer");
 var import_utils16 = require("@scure/btc-signer/utils");
-var INITIAL_TIME_LOCK2 = 2e3;
 var DepositService = class {
   config;
   connectionManager;
@@ -26060,7 +26839,6 @@ var DepositService = class {
     depositTx,
     vout
   }) {
-    const rootTx = new import_btc_signer4.Transaction({ version: 3 });
     const output = depositTx.getOutput(vout);
     if (!output) {
       throw new ValidationError("Invalid deposit transaction output", {
@@ -26078,39 +26856,345 @@ var DepositService = class {
         expected: "Output with script and amount"
       });
     }
-    let outputAmount = amount;
-    rootTx.addInput({
-      txid: getTxId(depositTx),
+    const depositOutPoint = {
+      txid: (0, import_utils15.hexToBytes)(getTxId(depositTx)),
       index: vout
-    });
-    rootTx.addOutput({
+    };
+    const depositTxOut = {
       script,
-      amount: outputAmount
+      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 { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+      sequence: INITIAL_SEQUENCE,
+      directSequence: INITIAL_DIRECT_SEQUENCE,
+      input: { txid: (0, import_utils15.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      directInput: { txid: (0, import_utils15.hexToBytes)(getTxId(directRootTx)), index: 0 },
+      amountSats: amount,
+      receivingPubkey: signingPubKey,
+      network: this.config.getNetwork()
     });
-    rootTx.addOutput(getEphemeralAnchorOutput());
-    const rootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
-    const refundTx = new import_btc_signer4.Transaction({ version: 3 });
-    const sequence = 1 << 30 | INITIAL_TIME_LOCK2;
-    refundTx.addInput({
-      txid: getTxId(rootTx),
-      index: 0,
-      sequence
+    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 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
+        },
+        directRootTxSigningJob: {
+          rawTx: directRootTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: directRootNonceCommitment.commitment
+        },
+        directRefundTxSigningJob: {
+          rawTx: directRefundTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: directRefundNonceCommitment.commitment
+        },
+        directFromCpfpRefundTxSigningJob: {
+          rawTx: directFromCpfpRefundTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: directFromCpfpRefundNonceCommitment.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 (!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 (!(0, import_utils16.equalBytes)(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 directRootSignature = await this.config.signer.signFrost({
+      message: directRootTxSighash,
+      publicKey: signingPubKey,
+      keyDerivation,
+      verifyingKey,
+      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 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: cpfpRootNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: cpfpRootSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    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: cpfpRefundNonceCommitment,
+      publicKey: signingPubKey,
+      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_v2({
+        intent: 0 /* CREATION */,
+        nodeSignatures: [
+          {
+            nodeId: treeResp.rootNodeSignatureShares.nodeId,
+            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: (0, import_utils15.hexToBytes)(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 refundP2trAddress = getP2TRAddressFromPublicKey(
-      signingPubKey,
-      this.config.getNetwork()
-    );
-    const refundAddress = btc5.Address(getNetwork(this.config.getNetwork())).decode(refundP2trAddress);
-    const refundPkScript = btc5.OutScript.encode(refundAddress);
-    refundTx.addOutput({
-      script: refundPkScript,
-      amount: outputAmount
+    const { cpfpRefundTx } = createRefundTxs({
+      sequence: INITIAL_SEQUENCE,
+      input: { txid: (0, import_utils15.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      amountSats: amount,
+      receivingPubkey: signingPubKey,
+      network: this.config.getNetwork()
     });
-    refundTx.addOutput(getEphemeralAnchorOutput());
-    const refundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const refundTxSighash = getSigHashFromTx(refundTx, 0, rootTx.getOutput(0));
+    const cpfpRefundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const cpfpRefundTxSighash = getSigHashFromTx(
+      cpfpRefundTx,
+      0,
+      cpfpRootTx.getOutput(0)
+    );
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
@@ -26124,14 +27208,14 @@ 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: refundNonceCommitment.commitment
+          signingNonceCommitment: cpfpRefundNonceCommitment.commitment
         }
       });
     } catch (error) {
@@ -26177,55 +27261,55 @@ 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 cpfpRefundSignature = await this.config.signer.signFrost({
+      message: cpfpRefundTxSighash,
       publicKey: signingPubKey,
       keyDerivation,
-      verifyingKey,
-      selfCommitment: refundNonceCommitment,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      selfCommitment: cpfpRefundNonceCommitment,
       statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
       adaptorPubKey: new Uint8Array()
     });
-    const rootAggregate = await this.config.signer.aggregateFrost({
-      message: rootTxSighash,
+    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 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()
     });
     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
           }
         ]
       });
@@ -26435,7 +27519,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(
@@ -26448,10 +27533,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 = (0, import_uuidv74.uuidv7)();
     let bolt11String = "";
@@ -26488,7 +27582,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: {
@@ -26500,7 +27594,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)
         },
@@ -28977,13 +30073,6 @@ function isTokenTransaction(tokenTransaction) {
 init_buffer();
 var import_utils20 = require("@noble/curves/abstract/utils");
 var import_btc_signer5 = require("@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;
-}
 var TreeCreationService = class {
   config;
   connectionManager;
@@ -29098,7 +30187,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}`);
     }
@@ -29115,7 +30204,7 @@ var TreeCreationService = class {
     );
     let finalizeResp;
     try {
-      finalizeResp = await sparkClient.finalize_node_signatures({
+      finalizeResp = await sparkClient.finalize_node_signatures_v2({
         nodeSignatures
       });
     } catch (error) {
@@ -29180,91 +30269,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 import_btc_signer5.Transaction({ 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: (0, import_utils20.hexToBytes)(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 import_btc_signer5.Transaction({ 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: (0, import_utils20.hexToBytes)(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
-    };
-    childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
-    childCreationNode.nodeTxSigningJob = childSigningJob;
-    const refundTx = new import_btc_signer5.Transaction({ version: 3 });
-    refundTx.addInput({
-      txid: getTxId(childTx),
-      index: 0,
-      sequence
-    });
-    const refundP2trAddress = getP2TRAddressFromPublicKey(
-      node.signingPublicKey,
+      rawTx: cpfpLeafTx.toBytes(),
+      signingNonceCommitment: cpfpLeafSigningCommitment.commitment
+    };
+    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: (0, import_utils20.hexToBytes)(getTxId(cpfpLeafTx)), index: 0 },
+      directInput: { txid: (0, import_utils20.hexToBytes)(getTxId(directLeafTx)), index: 0 },
+      amountSats: parentTxOut.amount,
+      receivingPubkey: node.signingPublicKey,
       network
-    );
-    const refundAddress = (0, import_btc_signer5.Address)(getNetwork(network)).decode(
-      refundP2trAddress
-    );
-    const refundPkScript = import_btc_signer5.OutScript.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;
   }
@@ -29273,11 +30382,7 @@ var TreeCreationService = class {
     if (!parentTxOutput?.script || !parentTxOutput?.amount) {
       throw new Error("parentTxOutput is undefined");
     }
-    const rootNodeTx = new import_btc_signer5.Transaction({ 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) {
@@ -29285,28 +30390,41 @@ var TreeCreationService = class {
       }
       const childAddress = (0, import_btc_signer5.Address)(getNetwork(network)).decode(child.address);
       const childPkScript = import_btc_signer5.OutScript.encode(childAddress);
-      rootNodeTx.addOutput({
+      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: (0, import_utils20.hexToBytes)(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) {
@@ -29314,13 +30432,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
     );
@@ -29329,19 +30449,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 */,
@@ -29351,30 +30471,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
       });
     }
-    let refundTxSignature = new Uint8Array();
-    if (creationNode.refundTxSigningCommitment) {
-      const rawTx = creationNode.refundTxSigningJob?.rawTx;
-      if (!rawTx) {
-        throw new Error("rawTx is undefined");
-      }
-      if (!creationNode.refundTxSigningJob?.signingPublicKey) {
-        throw new Error("signingPublicKey is undefined");
-      }
-      const refundTx = getTxFromRawTxBytes(rawTx);
-      const refundTxSighash = getSigHashFromTx(refundTx, 0, parentTxOutput);
-      const refundSigningResponse = await this.config.signer.signFrost({
-        message: refundTxSighash,
+    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 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 || !creationNode.directRefundTxSigningJob?.signingPublicKey || !creationNode.directFromCpfpRefundTxSigningJob?.signingPublicKey) {
+        throw new Error("refund transaction signingPublicKey is undefined");
+      }
+      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 */,
@@ -29384,27 +30558,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
       }
     };
   }
@@ -29467,8 +30683,45 @@ var SigningService = class {
   constructor(config) {
     this.config = config;
   }
-  async signRefunds(leaves, signingCommitments, receiverIdentityPubkey) {
+  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) {
@@ -29479,14 +30732,20 @@ var SigningService = class {
         });
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const nodeOutPoint = {
+      const cpfpNodeOutPoint = {
         txid: (0, import_utils21.hexToBytes)(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", {
@@ -29495,48 +30754,90 @@ var SigningService = class {
           expected: "Non-null amount"
         });
       }
-      const refundTx = createRefundTx(
-        nextSequence,
-        nodeOutPoint,
+      let directNodeTx;
+      let directNodeOutPoint;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+        directNodeOutPoint = {
+          txid: (0, import_utils21.hexToBytes)(getTxId(directNodeTx)),
+          index: 0
+        };
+      }
+      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+        sequence: nextSequence,
+        directSequence: nextDirectSequence,
+        input: cpfpNodeOutPoint,
+        directInput: directNodeOutPoint,
         amountSats,
-        receiverIdentityPubkey,
-        this.config.getNetwork()
+        receivingPubkey: receiverIdentityPubkey,
+        network: this.config.getNetwork()
+      });
+      const refundSighash = getSigHashFromTx(
+        cpfpRefundTx,
+        0,
+        nodeTx.getOutput(0)
       );
-      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"
-        });
+      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);
       }
-      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
-      });
-      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
+      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
+    };
   }
 };
 
@@ -29544,7 +30845,7 @@ var SigningService = class {
 init_buffer();
 var import_utils22 = require("@noble/curves/abstract/utils");
 var import_secp256k114 = require("@noble/curves/secp256k1");
-var btc6 = __toESM(require("@scure/btc-signer"), 1);
+var btc5 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer6 = require("@scure/btc-signer");
 var import_utils23 = require("@scure/btc-signer/utils");
 var STATIC_FAUCET_KEY = (0, import_utils22.hexToBytes)(
@@ -29690,7 +30991,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
   }
   async sendFaucetCoinToP2WPKHAddress(pubKey) {
     const sendToPubKeyTx = new import_btc_signer6.Transaction();
-    const p2wpkhAddress = btc6.p2wpkh(pubKey, getNetwork(4 /* LOCAL */)).address;
+    const p2wpkhAddress = btc5.p2wpkh(pubKey, getNetwork(4 /* LOCAL */)).address;
     if (!p2wpkhAddress) {
       throw new Error("Invalid P2WPKH address");
     }
@@ -29746,12 +31047,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",
@@ -30081,31 +31383,37 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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) {
@@ -30546,21 +31854,68 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         }
       }))
     );
-    const { transfer, signatureMap } = await this.transferService.startSwapSignRefund(
+    const {
+      transfer,
+      signatureMap,
+      directSignatureMap,
+      directFromCpfpSignatureMap
+    } = await this.transferService.startSwapSignRefund(
       leafKeyTweaks,
       (0, import_utils24.hexToBytes)(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 = [];
@@ -30569,37 +31924,113 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
           transfer.leaves[0].intermediateRefundTx
         ),
-        adaptor_added_signature: (0, import_utils24.bytesToHex)(adaptorSignature)
+        direct_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+          transfer.leaves[0].intermediateDirectRefundTx
+        ),
+        direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+          transfer.leaves[0].intermediateDirectFromCpfpRefundTx
+        ),
+        adaptor_added_signature: (0, import_utils24.bytesToHex)(cpfpAdaptorSignature),
+        direct_adaptor_added_signature: (0, import_utils24.bytesToHex)(directAdaptorSignature),
+        direct_from_cpfp_adaptor_added_signature: (0, import_utils24.bytesToHex)(
+          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: (0, import_utils24.bytesToHex)(
             leaf.intermediateRefundTx
           ),
-          adaptor_added_signature: (0, import_utils24.bytesToHex)(signature)
+          direct_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+            leaf.intermediateDirectRefundTx
+          ),
+          direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
+            leaf.intermediateDirectFromCpfpRefundTx
+          ),
+          adaptor_added_signature: (0, import_utils24.bytesToHex)(cpfpSignature),
+          direct_adaptor_added_signature: (0, import_utils24.bytesToHex)(directSignature),
+          direct_from_cpfp_adaptor_added_signature: (0, import_utils24.bytesToHex)(
+            directFromCpfpSignature
+          )
         });
       }
       const sspClient = this.getSspClient();
-      const adaptorPubkey = (0, import_utils24.bytesToHex)(
-        import_secp256k115.secp256k1.getPublicKey(adaptorPrivateKey)
+      const cpfpAdaptorPubkey = (0, import_utils24.bytesToHex)(
+        import_secp256k115.secp256k1.getPublicKey(cpfpAdaptorPrivateKey)
       );
+      if (!cpfpAdaptorPubkey) {
+        throw new Error("Failed to generate CPFP adaptor pubkey");
+      }
+      let directAdaptorPubkey;
+      if (directAdaptorPrivateKey.length > 0) {
+        directAdaptorPubkey = (0, import_utils24.bytesToHex)(
+          import_secp256k115.secp256k1.getPublicKey(directAdaptorPrivateKey)
+        );
+      }
+      let directFromCpfpAdaptorPubkey;
+      if (directFromCpfpAdaptorPrivateKey.length > 0) {
+        directFromCpfpAdaptorPubkey = (0, import_utils24.bytesToHex)(
+          import_secp256k115.secp256k1.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,
@@ -30608,6 +32039,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         idempotencyKey: (0, import_uuidv75.uuidv7)()
       });
       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({
@@ -30621,50 +32053,140 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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 = (0, import_utils24.hexToBytes)(leaf.rawUnsignedRefundTransaction);
-        const refundTx = getTxFromRawTxBytes(refundTxBytes);
-        const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
+        const cpfpNodeTx = getTxFromRawTxBytes(node.nodeTx);
+        const cpfpRefundTxBytes = (0, import_utils24.hexToBytes)(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 = (0, import_utils24.hexToBytes)(leaf.adaptorSignedSignature);
+        const cpfpAdaptorSignatureBytes = (0, import_utils24.hexToBytes)(
+          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 = (0, import_utils24.hexToBytes)(
+          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 = (0, import_utils24.hexToBytes)(
+          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 = (0, import_utils24.hexToBytes)(
+          leaf.directFromCpfpRawUnsignedRefundTransaction
+        );
+        const directFromCpfpRefundTx = getTxFromRawTxBytes(
+          directFromCpfpRefundTxBytes
+        );
+        const directFromCpfpSighash = getSigHashFromTx(
+          directFromCpfpRefundTx,
+          0,
+          cpfpNodeTx.getOutput(0)
+        );
+        const directFromCpfpAdaptorSignatureBytes = (0, import_utils24.hexToBytes)(
+          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: (0, import_utils24.bytesToHex)(adaptorPrivateKey),
+        adaptorSecretKey: (0, import_utils24.bytesToHex)(cpfpAdaptorPrivateKey),
+        directAdaptorSecretKey: (0, import_utils24.bytesToHex)(directAdaptorPrivateKey),
+        directFromCpfpAdaptorSecretKey: (0, import_utils24.bytesToHex)(
+          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({
@@ -30674,6 +32196,11 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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}`);
     }
@@ -31144,8 +32671,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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();
@@ -31156,9 +32684,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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();
@@ -31286,8 +32814,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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();
@@ -31298,9 +32827,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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();
@@ -31542,10 +33071,16 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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 {
@@ -31582,11 +33117,16 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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 {
@@ -31620,7 +33160,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         throw new Error(`parent node ${node.parentNodeId} not found`);
       }
       const { nodes: nodes2 } = await this.transferService.refreshTimelockNodes(
-        [node],
+        node,
         parentNode
       );
       if (nodes2.length !== 1) {
@@ -31669,7 +33209,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
               leavesToClaim.push({
                 leaf: {
                   ...leaf.leaf,
-                  refundTx: leaf.intermediateRefundTx
+                  refundTx: leaf.intermediateRefundTx,
+                  directRefundTx: leaf.intermediateDirectRefundTx,
+                  directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx
                 },
                 keyDerivation: {
                   type: "ecies" /* ECIES */,
@@ -31745,7 +33287,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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(
@@ -32033,6 +33575,8 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       await this.transferService.deliverTransferPackage(
         swapResponse.transfer,
         leavesToSend,
+        /* @__PURE__ */ new Map(),
+        /* @__PURE__ */ new Map(),
         /* @__PURE__ */ new Map()
       );
       const sspResponse = await sspClient.requestLightningSend({
@@ -32795,87 +34339,64 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.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
       );
@@ -32935,6 +34456,106 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   }
 };
 
+// src/spark-wallet/spark-wallet.node.ts
+var import_core13 = require("@lightsparkdev/core");
+var SparkWallet2 = class extends SparkWallet {
+  tracer = null;
+  wrapWithOtelSpan(name, fn) {
+    return async (...args) => {
+      if (!this.tracer) {
+        throw new Error("Tracer not initialized");
+      }
+      return await this.tracer.startActiveSpan(name, async (span) => {
+        const traceId = span.spanContext().traceId;
+        try {
+          const result = await fn(...args);
+          return result;
+        } catch (error) {
+          if (error instanceof Error) {
+            error.message += ` [traceId: ${traceId}]`;
+          } else if ((0, import_core13.isObject)(error)) {
+            error["traceId"] = traceId;
+          }
+          throw error;
+        } finally {
+          span.end();
+        }
+      });
+    };
+  }
+  async initializeTracer(tracerName) {
+    const { trace, propagation, context } = await import("@opentelemetry/api");
+    const { W3CTraceContextPropagator } = await import("@opentelemetry/core");
+    const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks");
+    const { BasicTracerProvider } = await import("@opentelemetry/sdk-trace-base");
+    trace.setGlobalTracerProvider(new BasicTracerProvider());
+    propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+    context.setGlobalContextManager(new AsyncLocalStorageContextManager());
+    this.tracer = trace.getTracer(tracerName);
+  }
+  getTraceName(methodName) {
+    return `SparkWallet.${methodName}`;
+  }
+  wrapPublicMethodsWithOtelSpan(methodName) {
+    const original = this[methodName];
+    if (typeof original !== "function") {
+      throw new Error(`Method ${methodName} is not a function on SparkWallet.`);
+    }
+    const wrapped = this.wrapWithOtelSpan(
+      this.getTraceName(methodName),
+      original.bind(this)
+    );
+    this[methodName] = wrapped;
+  }
+  wrapSparkWalletWithTracing() {
+    const methods = [
+      "getLeaves",
+      "getIdentityPublicKey",
+      "getSparkAddress",
+      "createSparkPaymentIntent",
+      "getSwapFeeEstimate",
+      "getTransfers",
+      "getBalance",
+      "getSingleUseDepositAddress",
+      "getStaticDepositAddress",
+      "queryStaticDepositAddresses",
+      "getClaimStaticDepositQuote",
+      "claimStaticDeposit",
+      "refundStaticDeposit",
+      "getUnusedDepositAddresses",
+      "claimDeposit",
+      "advancedDeposit",
+      "transfer",
+      "createLightningInvoice",
+      "payLightningInvoice",
+      "getLightningSendFeeEstimate",
+      "withdraw",
+      "getWithdrawalFeeQuote",
+      "getTransferFromSsp",
+      "getTransfer",
+      "transferTokens",
+      "batchTransferTokens",
+      "queryTokenTransactions",
+      "getLightningReceiveRequest",
+      "getLightningSendRequest",
+      "getCoopExitRequest",
+      "checkTimelock",
+      "testOnly_expireTimelock"
+    ];
+    methods.forEach((m) => this.wrapPublicMethodsWithOtelSpan(m));
+    this.initWallet = this.wrapWithOtelSpan(
+      this.getTraceName("initWallet"),
+      this.initWallet.bind(this)
+    );
+  }
+  async initWallet(mnemonicOrSeed, accountNumber) {
+    const res = super.initWallet(mnemonicOrSeed, accountNumber);
+    await this.initializeTracer(this.tracerId);
+    this.wrapSparkWalletWithTracing();
+    return res;
+  }
+};
+
 // src/spark-wallet/types.ts
 init_buffer();
 
@@ -32946,7 +34567,10 @@ setCrypto(cryptoImpl2);
   AuthenticationError,
   ConfigurationError,
   DEFAULT_FEE_SATS,
+  DIRECT_TIMELOCK_OFFSET,
   DefaultSparkSigner,
+  INITIAL_DIRECT_SEQUENCE,
+  INITIAL_SEQUENCE,
   InternalValidationError,
   KeyDerivationType,
   LRC_WALLET_NETWORK,
@@ -32959,6 +34583,8 @@ setCrypto(cryptoImpl2);
   RPCError,
   SparkSDKError,
   SparkWallet,
+  TEST_UNILATERAL_DIRECT_SEQUENCE,
+  TEST_UNILATERAL_SEQUENCE,
   TaprootOutputKeysGenerator,
   TaprootSparkSigner,
   TokenTransactionService,
@@ -32978,13 +34604,21 @@ setCrypto(cryptoImpl2);
   constructFeeBumpTx,
   constructUnilateralExitFeeBumpPackages,
   constructUnilateralExitTxs,
+  createConnectorRefundTransactions,
+  createLeafNodeTx,
+  createNodeTx,
+  createNodeTxs,
   createRefundTx,
+  createRefundTxs,
+  createRootTx,
   createSigningCommitment,
   createSigningNonce,
+  createSplitTx,
   decodeBech32mTokenIdentifier,
   decodeBytesToSigningCommitment,
   decodeBytesToSigningNonce,
   decodeSparkAddress,
+  doesLeafNeedRefresh,
   encodeBech32mTokenIdentifier,
   encodeSigningCommitmentToBytes,
   encodeSigningNonceToBytes,